Permalink
Cannot retrieve contributors at this time
Name already in use
A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
iisnode/src/iisnode/cprotocolbridge.cpp
Go to fileThis commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
1951 lines (1615 sloc)
74.4 KB
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#include "precomp.h" | |
HRESULT CProtocolBridge::PostponeProcessing(CNodeHttpStoredContext* context, DWORD dueTime) | |
{ | |
CAsyncManager* async = context->GetNodeApplication()->GetApplicationManager()->GetAsyncManager(); | |
LARGE_INTEGER delay; | |
delay.QuadPart = dueTime; | |
delay.QuadPart *= -10000; // convert from ms to 100ns units | |
return async->SetTimer(context->GetAsyncContext(), &delay); | |
} | |
#define LOCAL127 0x0100007F // 127.0.0.1 | |
BOOL CProtocolBridge::IsLocalCall(IHttpContext* ctx) | |
{ | |
PSOCKADDR src = ctx->GetRequest()->GetRemoteAddress(); | |
PSOCKADDR dest = ctx->GetRequest()->GetLocalAddress(); | |
if (AF_INET == src->sa_family && AF_INET == dest->sa_family) | |
{ | |
DWORD srcAddress = ntohl(((PSOCKADDR_IN)src)->sin_addr.s_addr); | |
DWORD destAddress = ntohl(((PSOCKADDR_IN)dest)->sin_addr.s_addr); | |
return srcAddress == destAddress || LOCAL127 == srcAddress || LOCAL127 == destAddress; | |
} | |
else if (AF_INET6 == src->sa_family && AF_INET6 == dest->sa_family) | |
{ | |
IN6_ADDR* srcAddress = &((PSOCKADDR_IN6)src)->sin6_addr; | |
IN6_ADDR* destAddress = &((PSOCKADDR_IN6)dest)->sin6_addr; | |
if (0 == memcmp(srcAddress, destAddress, sizeof IN6_ADDR)) | |
{ | |
return TRUE; | |
} | |
if (IN6_IS_ADDR_LOOPBACK(srcAddress) || IN6_IS_ADDR_LOOPBACK(destAddress)) | |
{ | |
return TRUE; | |
} | |
} | |
return FALSE; | |
} | |
BOOL CProtocolBridge::SendIisnodeError(IHttpContext* httpCtx, HRESULT hr) | |
{ | |
if (IISNODE_ERROR_UNABLE_TO_READ_CONFIGURATION == hr || IISNODE_ERROR_UNABLE_TO_READ_CONFIGURATION_OVERRIDE == hr) | |
{ | |
if (CProtocolBridge::IsLocalCall(httpCtx)) | |
{ | |
switch (hr) { | |
default: | |
return FALSE; | |
case IISNODE_ERROR_UNABLE_TO_READ_CONFIGURATION: | |
CProtocolBridge::SendSyncResponse( | |
httpCtx, | |
200, | |
"OK", | |
hr, | |
TRUE, | |
"iisnode was unable to read the configuration file. Make sure the web.config file syntax is correct. In particular, verify the " | |
" <a href=""https://github.com/tjanczuk/iisnode/blob/master/src/samples/configuration/web.config"">" | |
"iisnode configuration section</a> matches the expected schema. The schema of the iisnode section that your version of iisnode requires is stored in the " | |
"%systemroot%\\system32\\inetsrv\\config\\schema\\iisnode_schema.xml file."); | |
break; | |
case IISNODE_ERROR_UNABLE_TO_READ_CONFIGURATION_OVERRIDE: | |
CProtocolBridge::SendSyncResponse( | |
httpCtx, | |
200, | |
"OK", | |
hr, | |
TRUE, | |
"iisnode was unable to read the configuration file iisnode.yml. Make sure the iisnode.yml file syntax is correct. For reference, check " | |
" <a href=""https://github.com/tjanczuk/iisnode/blob/master/src/samples/configuration/iisnode.yml"">" | |
"the sample iisnode.yml file</a>. The property names recognized in the iisnode.yml file of your version of iisnode are stored in the " | |
"%systemroot%\\system32\\inetsrv\\config\\schema\\iisnode_schema.xml file."); | |
break; | |
}; | |
return TRUE; | |
} | |
else | |
{ | |
return FALSE; | |
} | |
} | |
if (!CModuleConfiguration::GetDevErrorsEnabled(httpCtx)) | |
{ | |
return FALSE; | |
} | |
switch (hr) { | |
default: | |
return FALSE; | |
case IISNODE_ERROR_UNRECOGNIZED_DEBUG_COMMAND: | |
CProtocolBridge::SendSyncResponse( | |
httpCtx, | |
200, | |
"OK", | |
hr, | |
TRUE, | |
"Unrecognized debugging command. Supported commands are ?debug (default), ?brk, and ?kill."); | |
break; | |
case IISNODE_ERROR_UNABLE_TO_FIND_DEBUGGING_PORT: | |
CProtocolBridge::SendSyncResponse( | |
httpCtx, | |
200, | |
"OK", | |
hr, | |
TRUE, | |
"The debugger was unable to acquire a TCP port to establish communication with the debugee. " | |
"This may be due to lack of free TCP ports in the range specified in the <a href=""https://github.com/tjanczuk/iisnode/blob/master/src/samples/configuration/web.config"">" | |
"system.webServer/iisnode/@debuggerPortRange</a> configuration " | |
"section, or due to lack of permissions to create TCP listeners by the identity of the IIS worker process."); | |
break; | |
case IISNODE_ERROR_UNABLE_TO_CONNECT_TO_DEBUGEE: | |
CProtocolBridge::SendSyncResponse( | |
httpCtx, | |
200, | |
"OK", | |
hr, | |
TRUE, | |
"The debugger was unable to connect to the the debugee. " | |
"This may be due to the debugee process terminating during startup (e.g. due to an unhandled exception) or " | |
"failing to establish a TCP listener on the debugging port. "); | |
break; | |
case IISNODE_ERROR_INSPECTOR_NOT_FOUND: | |
CProtocolBridge::SendSyncResponse( | |
httpCtx, | |
200, | |
"OK", | |
hr, | |
TRUE, | |
"The version of iisnode installed on the server does not support remote debugging. " | |
"To use remote debugging, please update your iisnode installation on the server to one available from " | |
"<a href=""http://github.com/tjanczuk/iisnode/downloads"">http://github.com/tjanczuk/iisnode/downloads</a>. " | |
"We apologize for inconvenience."); | |
break; | |
case IISNODE_ERROR_UNABLE_TO_CREATE_DEBUGGER_FILES: | |
CProtocolBridge::SendSyncResponse( | |
httpCtx, | |
200, | |
"OK", | |
hr, | |
TRUE, | |
"The iisnode module is unable to deploy supporting files necessary to initialize the debugger. " | |
"Please check that the identity of the IIS application pool running the node.js application has read and write access " | |
"permissions to the directory on the server where the node.js application is located."); | |
break; | |
case IISNODE_ERROR_UNABLE_TO_START_NODE_EXE: | |
char* errorMessage = | |
"The iisnode module is unable to start the node.exe process. Make sure the node.exe executable is available " | |
"at the location specified in the <a href=""https://github.com/tjanczuk/iisnode/blob/master/src/samples/configuration/web.config"">" | |
"system.webServer/iisnode/@nodeProcessCommandLine</a> element of web.config. " | |
"By default node.exe is expected in one of the directories listed in the PATH environment variable."; | |
CProtocolBridge::SendSyncResponse( | |
httpCtx, | |
200, | |
"OK", | |
hr, | |
TRUE, | |
errorMessage); | |
break; | |
}; | |
return TRUE; | |
} | |
BOOL CProtocolBridge::SendIisnodeError(CNodeHttpStoredContext* ctx, HRESULT hr) | |
{ | |
if (CProtocolBridge::SendIisnodeError(ctx->GetHttpContext(), hr)) | |
{ | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode request processing failed for reasons recognized by iisnode", WINEVENT_LEVEL_VERBOSE, ctx->GetActivityId()); | |
if (INVALID_HANDLE_VALUE != ctx->GetPipe()) | |
{ | |
CloseHandle(ctx->GetPipe()); | |
ctx->SetPipe(INVALID_HANDLE_VALUE); | |
} | |
CProtocolBridge::FinalizeResponseCore( | |
ctx, | |
RQ_NOTIFICATION_FINISH_REQUEST, | |
hr, | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider(), | |
L"iisnode posts completion from SendIisnodeError", | |
WINEVENT_LEVEL_VERBOSE); | |
return TRUE; | |
} | |
return FALSE; | |
} | |
BOOL CProtocolBridge::SendDevError(CNodeHttpStoredContext* context, | |
USHORT status, | |
USHORT subStatus, | |
PCTSTR reason, | |
HRESULT hresult, | |
BOOL disableCache) | |
{ | |
HRESULT hr; | |
DWORD rawLogSize, htmlLogSize, htmlTotalSize; | |
IHttpContext* ctx; | |
char* rawLog; | |
char* templ1; | |
char* templ2; | |
char* templ3; | |
char* html; | |
char* current; | |
if (500 <= status && CModuleConfiguration::GetDevErrorsEnabled(context->GetHttpContext()) && NULL != context->GetNodeProcess()) | |
{ | |
// return a friendly HTTP 200 response with HTML entity body that contains error details | |
// and the content of node.exe stdout/err, if available | |
ctx = context->GetHttpContext(); | |
rawLog = context->GetNodeProcess()->TryGetLog(ctx, &rawLogSize); | |
templ1 = | |
"<p>iisnode encountered an error when processing the request.</p><pre style=\"background-color: eeeeee\">" | |
"HRESULT: 0x%x\n" | |
"HTTP status: %d\n" | |
"HTTP subStatus: %d\n" | |
"HTTP reason: %s</pre>" | |
"<p>You are receiving this HTTP 200 response because <a href=""https://github.com/tjanczuk/iisnode/blob/master/src/samples/configuration/web.config"">" | |
"system.webServer/iisnode/@devErrorsEnabled</a> configuration setting is 'true'.</p>" | |
"<p>In addition to the log of stdout and stderr of the node.exe process, consider using " | |
"<a href=""http://tomasz.janczuk.org/2011/11/debug-nodejs-applications-on-windows.html"">debugging</a> " | |
"and <a href=""http://tomasz.janczuk.org/2011/09/using-event-tracing-for-windows-to.html"">ETW traces</a> to further diagnose the problem.</p>"; | |
templ2 = "<p>The node.exe process has not written any information to stderr or iisnode was unable to capture this information. " | |
"Frequent reason is that the iisnode module is unable to create a log file to capture stdout and stderr output from node.exe. " | |
"Please check that the identity of the IIS application pool running the node.js application has read and write access " | |
"permissions to the directory on the server where the node.js application is located. Alternatively you can disable logging " | |
"by setting <a href=""https://github.com/tjanczuk/iisnode/blob/master/src/samples/configuration/web.config"">" | |
"system.webServer/iisnode/@loggingEnabled</a> element of web.config to 'false'."; | |
templ3="<p>You may get additional information about this error condition by logging stdout and stderr of the node.exe process." | |
"To enable logging, set the <a href=""https://github.com/tjanczuk/iisnode/blob/master/src/samples/configuration/web.config"">" | |
"system.webServer/iisnode/@loggingEnabled</a> configuration setting to 'true' (current value is 'false').</p>"; | |
// calculate HTML encoded size of the log | |
htmlLogSize = 0; | |
for (int i = 0; i < rawLogSize; i++) | |
{ | |
if (rawLog[i] >= 0 && rawLog[i] <= 0x8 | |
|| rawLog[i] >= 0xb && rawLog[i] <= 0xc | |
|| rawLog[i] >= 0xe && rawLog[i] <= 0x1f | |
|| rawLog[i] >= 0x80 && rawLog[i] <= 0x9f) | |
{ | |
// characters disallowed in HTML will be converted to [xAB] notation, thus taking 5 bytes | |
htmlLogSize += 5; | |
} | |
else | |
{ | |
switch (rawLog[i]) | |
{ | |
default: | |
htmlLogSize++; | |
break; | |
case '&': | |
htmlLogSize += 5; // & | |
break; | |
case '<': | |
case '>': | |
htmlLogSize += 4; // < > | |
break; | |
case '"': | |
case '\'': | |
htmlLogSize += 6; // " ' | |
break; | |
}; | |
} | |
} | |
// calculate total size of HTML and allocate memory | |
htmlTotalSize = strlen(templ1) + 20 /* hresult */ + 20 /* status code */ + strlen(reason) + strlen(templ2) /* log content heading */ + htmlLogSize; | |
ErrorIf(NULL == (html = (char*)ctx->AllocateRequestMemory(htmlTotalSize)), ERROR_NOT_ENOUGH_MEMORY); | |
RtlZeroMemory(html, htmlTotalSize); | |
// construct the HTML | |
sprintf(html, templ1, hresult, status, subStatus, reason); | |
if (0 == rawLogSize) | |
{ | |
if (CModuleConfiguration::GetLoggingEnabled(ctx)) | |
{ | |
strcat(html, templ2); | |
} | |
else | |
{ | |
strcat(html, templ3); | |
} | |
} | |
else | |
{ | |
strcat(html, "<p>The last 64k of the output generated by the node.exe process to stderr is shown below:</p><pre style=\"background-color: eeeeee\">"); | |
current = html + strlen(html); | |
if (htmlLogSize == rawLogSize) | |
{ | |
// no HTML encoding is necessary | |
memcpy(current, rawLog, rawLogSize); | |
} | |
else | |
{ | |
// HTML encode the log | |
for (int i = 0; i < rawLogSize; i++) | |
{ | |
if (rawLog[i] >= 0 && rawLog[i] <= 0x8 | |
|| rawLog[i] >= 0xb && rawLog[i] <= 0xc | |
|| rawLog[i] >= 0xe && rawLog[i] <= 0x1f | |
|| rawLog[i] >= 0x80 && rawLog[i] <= 0x9f) | |
{ | |
// characters disallowed in HTML are converted to [xAB] notation | |
*current++ = '['; | |
*current++ = 'x'; | |
*current = rawLog[i] >> 4; | |
*current++ += *current > 9 ? 'A' - 10 : '0'; | |
*current = rawLog[i] & 15; | |
*current++ += *current > 9 ? 'A' - 10 : '0'; | |
*current++ = ']'; | |
} | |
else | |
{ | |
switch (rawLog[i]) | |
{ | |
default: | |
*current++ = rawLog[i]; | |
break; | |
case '&': | |
*current++ = '&'; | |
*current++ = 'a'; | |
*current++ = 'm'; | |
*current++ = 'p'; | |
*current++ = ';'; | |
break; | |
case '<': | |
*current++ = '&'; | |
*current++ = 'l'; | |
*current++ = 't'; | |
*current++ = ';'; | |
break; | |
case '>': | |
*current++ = '&'; | |
*current++ = 'g'; | |
*current++ = 't'; | |
*current++ = ';'; | |
break; | |
case '"': | |
*current++ = '&'; | |
*current++ = 'q'; | |
*current++ = 'u'; | |
*current++ = 'o'; | |
*current++ = 't'; | |
*current++ = ';'; | |
break; | |
case '\'': | |
*current++ = '&'; | |
*current++ = 'a'; | |
*current++ = 'p'; | |
*current++ = 'o'; | |
*current++ = 's'; | |
*current++ = ';'; | |
break; | |
}; | |
} | |
} | |
} | |
} | |
// send the response | |
CheckError(CProtocolBridge::SendSyncResponse( | |
ctx, | |
200, | |
"OK", | |
hresult, | |
TRUE, | |
html)); | |
return true; | |
} | |
Error: | |
return false; | |
} | |
HRESULT CProtocolBridge::SendEmptyResponse(CNodeHttpStoredContext* context, USHORT status, USHORT subStatus, PCTSTR reason, HRESULT hresult, BOOL disableCache) | |
{ | |
context->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(context->GetHttpContext(), | |
L"iisnode request processing failed for reasons unrecognized by iisnode", WINEVENT_LEVEL_VERBOSE, context->GetActivityId()); | |
if (INVALID_HANDLE_VALUE != context->GetPipe()) | |
{ | |
CloseHandle(context->GetPipe()); | |
context->SetPipe(INVALID_HANDLE_VALUE); | |
} | |
if (!CProtocolBridge::SendDevError(context, status, subStatus, reason, hresult, disableCache)) | |
{ | |
// return default IIS response | |
CProtocolBridge::SendEmptyResponse(context->GetHttpContext(), status, subStatus, reason, hresult, disableCache); | |
} | |
CProtocolBridge::FinalizeResponseCore( | |
context, | |
RQ_NOTIFICATION_FINISH_REQUEST, | |
hresult, | |
context->GetNodeApplication()->GetApplicationManager()->GetEventProvider(), | |
L"iisnode posts completion from SendEmtpyResponse", | |
WINEVENT_LEVEL_VERBOSE); | |
return S_OK; | |
} | |
HRESULT CProtocolBridge::SendSyncResponse(IHttpContext* httpCtx, USHORT status, PCTSTR reason, HRESULT hresult, BOOL disableCache, PCSTR htmlBody) | |
{ | |
HRESULT hr; | |
DWORD bytesSent; | |
HTTP_DATA_CHUNK body; | |
CProtocolBridge::SendEmptyResponse(httpCtx, status, 0, reason, hresult, disableCache); | |
IHttpResponse* response = httpCtx->GetResponse(); | |
response->SetHeader(HttpHeaderContentType, "text/html", 9, TRUE); | |
body.DataChunkType = HttpDataChunkFromMemory; | |
body.FromMemory.pBuffer = (PVOID)htmlBody; | |
body.FromMemory.BufferLength = strlen(htmlBody); | |
CheckError(response->WriteEntityChunks(&body, 1, FALSE, FALSE, &bytesSent)); | |
return S_OK; | |
Error: | |
return hr; | |
} | |
void CProtocolBridge::SendEmptyResponse(IHttpContext* httpCtx, USHORT status, USHORT subStatus, PCTSTR reason, HRESULT hresult, BOOL disableCache) | |
{ | |
if (!httpCtx->GetResponseHeadersSent()) | |
{ | |
httpCtx->GetResponse()->Clear(); | |
httpCtx->GetResponse()->SetStatus(status, reason, subStatus, hresult); | |
if (disableCache) | |
{ | |
httpCtx->GetResponse()->SetHeader(HttpHeaderCacheControl, "no-cache", 8, TRUE); | |
} | |
} | |
} | |
HRESULT CProtocolBridge::InitiateRequest(CNodeHttpStoredContext* context) | |
{ | |
HRESULT hr; | |
BOOL requireChildContext = FALSE; | |
BOOL mainDebuggerPage = FALSE; | |
IHttpContext* child = NULL; | |
BOOL completionExpected; | |
// determine what the target path of the request is | |
if (context->GetNodeApplication()->IsDebugger()) | |
{ | |
// All debugger URLs require rewriting. Requests for static content will be processed using a child http context and served | |
// by a static file handler. Debugging protocol requests will continue executing in the current context and be processed | |
// by the node-inspector application. | |
CheckError(CNodeDebugger::DispatchDebuggingRequest(context, &requireChildContext, &mainDebuggerPage)); | |
} | |
else | |
{ | |
// For application requests, if the URL rewrite module had been used to rewrite the URL, | |
// present the original URL to the node.js application instead of the re-written one. | |
PCSTR url; | |
USHORT urlLength; | |
IHttpRequest* request = context->GetHttpContext()->GetRequest(); | |
if (NULL == (url = request->GetHeader("X-Original-URL", &urlLength))) | |
{ | |
HTTP_REQUEST* raw = request->GetRawHttpRequest(); | |
// Fix for https://github.com/tjanczuk/iisnode/issues/296 | |
PSTR path = NULL; | |
int pathSizeA = 0; | |
int cchAbsPathLength = (raw->CookedUrl.AbsPathLength + raw->CookedUrl.QueryStringLength) >> 1; | |
ErrorIf(0 == (pathSizeA = WideCharToMultiByte(CP_ACP, 0, raw->CookedUrl.pAbsPath, cchAbsPathLength, NULL, 0, NULL, NULL)), E_FAIL); | |
ErrorIf(NULL == (path = (TCHAR*)context->GetHttpContext()->AllocateRequestMemory(pathSizeA + 1)), ERROR_NOT_ENOUGH_MEMORY); | |
ErrorIf(pathSizeA != WideCharToMultiByte(CP_ACP, 0, raw->CookedUrl.pAbsPath, cchAbsPathLength, path, pathSizeA, NULL, NULL), E_FAIL); | |
path[pathSizeA] = 0; | |
context->SetTargetUrl(path, pathSizeA); | |
} | |
else | |
{ | |
context->SetTargetUrl(url, urlLength); | |
} | |
} | |
// determine how to process the request | |
if (requireChildContext) | |
{ | |
CheckError(context->GetHttpContext()->CloneContext(CLONE_FLAG_BASICS | CLONE_FLAG_ENTITY | CLONE_FLAG_HEADERS, &child)); | |
if (mainDebuggerPage) | |
{ | |
// Prevent client caching of responses to requests for debugger entry points e.g. app.js/debug or app.js/debug?brk | |
// This is to allow us to run initialization logic on the server if necessary every time user refreshes the page | |
// Static content subordinate to the main debugger page is eligible for client side caching | |
child->GetResponse()->SetHeader(HttpHeaderCacheControl, "no-cache", 8, TRUE); | |
} | |
CheckError(child->GetRequest()->SetUrl(context->GetTargetUrl(), context->GetTargetUrlLength(), FALSE)); | |
context->SetChildContext(child); | |
context->SetNextProcessor(CProtocolBridge::ChildContextCompleted); | |
CheckError(context->GetHttpContext()->ExecuteRequest(TRUE, child, 0, NULL, &completionExpected)); | |
if (!completionExpected) | |
{ | |
CProtocolBridge::ChildContextCompleted(S_OK, 0, context->GetOverlapped()); | |
} | |
} | |
else | |
{ | |
context->SetNextProcessor(CProtocolBridge::CreateNamedPipeConnection); | |
CProtocolBridge::CreateNamedPipeConnection(S_OK, 0, context->InitializeOverlapped()); | |
} | |
return S_OK; | |
Error: | |
if (child) | |
{ | |
child->ReleaseClonedContext(); | |
child = NULL; | |
context->SetChildContext(NULL); | |
} | |
return hr; | |
} | |
void WINAPI CProtocolBridge::ChildContextCompleted(DWORD error, DWORD bytesTransfered, LPOVERLAPPED overlapped) | |
{ | |
CNodeHttpStoredContext* ctx = CNodeHttpStoredContext::Get(overlapped); | |
ctx->GetChildContext()->ReleaseClonedContext(); | |
ctx->SetChildContext(NULL); | |
if (S_OK == error) | |
{ | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode finished processing child http request", WINEVENT_LEVEL_VERBOSE, ctx->GetActivityId()); | |
} | |
else | |
{ | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode failed to process child http request", WINEVENT_LEVEL_ERROR, ctx->GetActivityId()); | |
} | |
ctx->SetHresult(error); | |
ctx->SetRequestNotificationStatus(RQ_NOTIFICATION_CONTINUE); | |
ctx->SetNextProcessor(NULL); | |
CProtocolBridge::FinalizeResponseCore( | |
ctx, | |
RQ_NOTIFICATION_CONTINUE, | |
error, | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider(), | |
L"iisnode posts completion from ChildContextCompleted", | |
WINEVENT_LEVEL_VERBOSE); | |
return; | |
} | |
void WINAPI CProtocolBridge::CreateNamedPipeConnection(DWORD error, DWORD bytesTransfered, LPOVERLAPPED overlapped) | |
{ | |
HRESULT hr; | |
CNodeHttpStoredContext* ctx = CNodeHttpStoredContext::Get(overlapped); | |
HANDLE pipe = INVALID_HANDLE_VALUE; | |
DWORD retry = ctx->GetConnectionRetryCount(); | |
if (0 == retry) | |
{ | |
// only the first connection attempt uses connections from the pool | |
pipe = ctx->GetNodeProcess()->GetConnectionPool()->Take(); | |
} | |
if (INVALID_HANDLE_VALUE == pipe) | |
{ | |
ErrorIf(INVALID_HANDLE_VALUE == (pipe = CreateFile( | |
ctx->GetNodeProcess()->GetNamedPipeName(), | |
GENERIC_READ | GENERIC_WRITE, | |
0, | |
NULL, | |
OPEN_EXISTING, | |
FILE_FLAG_OVERLAPPED, | |
NULL)), | |
GetLastError()); | |
ErrorIf(!SetFileCompletionNotificationModes( | |
pipe, | |
FILE_SKIP_COMPLETION_PORT_ON_SUCCESS | FILE_SKIP_SET_EVENT_ON_HANDLE), | |
GetLastError()); | |
ctx->SetIsConnectionFromPool(FALSE); | |
ctx->GetNodeApplication()->GetApplicationManager()->GetAsyncManager()->AddAsyncCompletionHandle(pipe); | |
} | |
else | |
{ | |
ctx->SetIsConnectionFromPool(TRUE); | |
} | |
ctx->SetPipe(pipe); | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode created named pipe connection to the node.exe process", WINEVENT_LEVEL_VERBOSE, ctx->GetActivityId()); | |
CProtocolBridge::SendHttpRequestHeaders(ctx); | |
return; | |
Error: | |
if (INVALID_HANDLE_VALUE == pipe) | |
{ | |
if (retry >= CModuleConfiguration::GetMaxNamedPipeConnectionRetry(ctx->GetHttpContext())) | |
{ | |
if (hr == ERROR_PIPE_BUSY) | |
{ | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode was unable to establish named pipe connection to the node.exe process because the named pipe server is too busy", WINEVENT_LEVEL_ERROR, ctx->GetActivityId()); | |
CProtocolBridge::SendEmptyResponse(ctx, 503, CNodeConstants::IISNODE_ERROR_PIPE_CONNECTION_TOO_BUSY, _T("Service Unavailable"), hr); | |
} | |
else | |
{ | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode was unable to establish named pipe connection to the node.exe process", WINEVENT_LEVEL_ERROR, ctx->GetActivityId()); | |
CProtocolBridge::SendEmptyResponse( ctx, | |
500, | |
CNodeConstants::IISNODE_ERROR_PIPE_CONNECTION, | |
_T("Internal Server Error"), | |
hr ); | |
} | |
} | |
else if (ctx->GetNodeProcess()->HasProcessExited()) | |
{ | |
// the process has exited, likely due to initialization error | |
// stop trying to establish the named pipe connection to minimize the failure latency | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode was unable to establish named pipe connection to the node.exe process before the process terminated", WINEVENT_LEVEL_ERROR, ctx->GetActivityId()); | |
CProtocolBridge::SendEmptyResponse( ctx, | |
500, | |
CNodeConstants::IISNODE_ERROR_PIPE_CONNECTION_BEFORE_PROCESS_TERMINATED, | |
_T("Internal Server Error"), | |
hr ); | |
} | |
else | |
{ | |
ctx->SetConnectionRetryCount(retry + 1); | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode scheduled a retry of a named pipe connection to the node.exe process ", WINEVENT_LEVEL_INFO, ctx->GetActivityId()); | |
CProtocolBridge::PostponeProcessing(ctx, CModuleConfiguration::GetNamedPipeConnectionRetryDelay(ctx->GetHttpContext())); | |
} | |
} | |
else | |
{ | |
CloseHandle(pipe); | |
pipe = INVALID_HANDLE_VALUE; | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode was unable to configure the named pipe connection to the node.exe process", WINEVENT_LEVEL_ERROR, ctx->GetActivityId()); | |
CProtocolBridge::SendEmptyResponse( ctx, | |
500, | |
CNodeConstants::IISNODE_ERROR_CONFIGURE_PIPE_CONNECTION, | |
_T("Internal Server Error"), | |
hr ); | |
} | |
return; | |
} | |
void CProtocolBridge::SendHttpRequestHeaders(CNodeHttpStoredContext* context) | |
{ | |
HRESULT hr; | |
DWORD length; | |
IHttpRequest *request; | |
PCSTR pszConnectionHeader = NULL; | |
// set the start time of the request | |
GetSystemTimeAsFileTime(context->GetStartTime()); | |
// capture ETW provider since after a successful call to WriteFile the context may be asynchronously deleted | |
CNodeEventProvider* etw = context->GetNodeApplication()->GetApplicationManager()->GetEventProvider(); | |
GUID activityId; | |
memcpy(&activityId, context->GetActivityId(), sizeof GUID); | |
// request the named pipe to be kept alive by the server after the response is sent | |
// to enable named pipe connection pooling | |
request = context->GetHttpContext()->GetRequest(); | |
pszConnectionHeader = request->GetHeader(HttpHeaderConnection); | |
if( pszConnectionHeader == NULL || | |
(pszConnectionHeader != NULL && stricmp(pszConnectionHeader, "upgrade") != 0)) | |
{ | |
CheckError(request->SetHeader(HttpHeaderConnection, "keep-alive", 10, TRUE)); | |
} | |
// Expect: 100-continue has been processed by IIS - do not propagate it up to node.js since node will | |
// attempt to process it again | |
USHORT expectLength; | |
PCSTR expect = request->GetHeader(HttpHeaderExpect, &expectLength); | |
if (NULL != expect && 0 == strnicmp(expect, "100-continue", expectLength)) | |
{ | |
CheckError(request->DeleteHeader(HttpHeaderExpect)); | |
} | |
// determine if the request body had been chunked; IIS decodes chunked encoding, so it | |
// must be re-applied when sending the request entity body | |
USHORT encodingLength; | |
PCSTR encoding = request->GetHeader(HttpHeaderTransferEncoding, &encodingLength); | |
if (NULL != encoding && 0 == strnicmp(encoding, "chunked;", encodingLength > 8 ? 8 : encodingLength)) | |
{ | |
context->SetIsChunked(TRUE); | |
context->SetIsLastChunk(FALSE); | |
} | |
// serialize and send request headers | |
CheckError(CHttpProtocol::SerializeRequestHeaders(context, context->GetBufferRef(), context->GetBufferSizeRef(), &length)); | |
context->SetNextProcessor(CProtocolBridge::SendHttpRequestHeadersCompleted); | |
if (WriteFile(context->GetPipe(), context->GetBuffer(), length, NULL, context->InitializeOverlapped())) | |
{ | |
// completed synchronously | |
etw->Log(context->GetHttpContext(), L"iisnode initiated sending http request headers to the node.exe process and completed synchronously", | |
WINEVENT_LEVEL_VERBOSE, | |
&activityId); | |
// despite IO completion ports are used, asynchronous callback will not be invoked because in | |
// CProtocolBridge:CreateNamedPipeConnection the SetFileCompletionNotificationModes function was called | |
// - see http://msdn.microsoft.com/en-us/library/windows/desktop/aa365683(v=vs.85).aspx | |
// and http://msdn.microsoft.com/en-us/library/windows/desktop/aa365538(v=vs.85).aspx | |
CProtocolBridge::SendHttpRequestHeadersCompleted(S_OK, 0, context->GetOverlapped()); | |
} | |
else | |
{ | |
hr = GetLastError(); | |
if (ERROR_IO_PENDING == hr) | |
{ | |
} | |
else | |
{ | |
// error | |
if (context->GetIsConnectionFromPool()) | |
{ | |
// communication over a connection from the connection pool failed | |
// try to create a brand new connection instead | |
context->SetConnectionRetryCount(1); | |
CProtocolBridge::CreateNamedPipeConnection(S_OK, 0, context->GetOverlapped()); | |
} | |
else | |
{ | |
etw->Log(context->GetHttpContext(), L"iisnode failed to initiate sending http request headers to the node.exe process", | |
WINEVENT_LEVEL_ERROR, | |
&activityId); | |
CProtocolBridge::SendEmptyResponse( context, | |
500, | |
CNodeConstants::IISNODE_ERROR_FAILED_INIT_SEND_HTTP_HEADERS, | |
_T("Internal Server Error"), | |
hr ); | |
} | |
} | |
} | |
return; | |
Error: | |
etw->Log(context->GetHttpContext(), L"iisnode failed to serialize http request headers", | |
WINEVENT_LEVEL_ERROR, | |
&activityId); | |
CProtocolBridge::SendEmptyResponse( context, | |
500, | |
CNodeConstants::IISNODE_ERROR_FAILED_SERIALIZE_HTTP_HEADERS, | |
_T("Internal Server Error"), | |
hr ); | |
return; | |
} | |
void WINAPI CProtocolBridge::SendHttpRequestHeadersCompleted(DWORD error, DWORD bytesTransfered, LPOVERLAPPED overlapped) | |
{ | |
HRESULT hr; | |
CNodeHttpStoredContext* ctx = CNodeHttpStoredContext::Get(overlapped); | |
CheckError(error); | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode finished sending http request headers to the node.exe process", WINEVENT_LEVEL_VERBOSE, ctx->GetActivityId()); | |
CProtocolBridge::ReadRequestBody(ctx); | |
return; | |
Error: | |
if (ctx->GetIsConnectionFromPool()) | |
{ | |
// communication over a connection from the connection pool failed | |
// try to create a brand new connection instead | |
ctx->SetConnectionRetryCount(1); | |
CProtocolBridge::CreateNamedPipeConnection(S_OK, 0, ctx->GetOverlapped()); | |
} | |
else | |
{ | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode failed to send http request headers to the node.exe process", WINEVENT_LEVEL_ERROR, ctx->GetActivityId()); | |
CProtocolBridge::SendEmptyResponse( ctx, | |
500, | |
CNodeConstants::IISNODE_ERROR_FAILED_SEND_HTTP_HEADERS, | |
_T("Internal Server Error"), | |
hr ); | |
} | |
return; | |
} | |
void CProtocolBridge::ReadRequestBody(CNodeHttpStoredContext* context) | |
{ | |
HRESULT hr; | |
DWORD bytesReceived = 0; | |
BOOL completionPending = FALSE; | |
BOOL continueSynchronouslyNow = TRUE; | |
if (0 < context->GetHttpContext()->GetRequest()->GetRemainingEntityBytes() || context->GetIsUpgrade()) | |
{ | |
context->SetNextProcessor(CProtocolBridge::ReadRequestBodyCompleted); | |
if (context->GetIsChunked()) | |
{ | |
CheckError(context->GetHttpContext()->GetRequest()->ReadEntityBody(context->GetChunkBuffer(), context->GetChunkBufferSize(), TRUE, &bytesReceived, &completionPending)); | |
} | |
else | |
{ | |
CheckError(context->GetHttpContext()->GetRequest()->ReadEntityBody(context->GetBuffer(), context->GetBufferSize(), TRUE, &bytesReceived, &completionPending)); | |
} | |
if (!completionPending) | |
{ | |
context->SetContinueSynchronously(TRUE); | |
continueSynchronouslyNow = FALSE; | |
context->SetBytesCompleted(bytesReceived); | |
} | |
} | |
if (!completionPending) | |
{ | |
context->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(context->GetHttpContext(), | |
L"iisnode initiated reading http request body chunk and completed synchronously", WINEVENT_LEVEL_VERBOSE, context->GetActivityId()); | |
context->SetBytesCompleted(bytesReceived); | |
if (continueSynchronouslyNow) | |
{ | |
CProtocolBridge::ReadRequestBodyCompleted(S_OK, 0, context->GetOverlapped()); | |
} | |
} | |
else | |
{ | |
//context->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(context->GetHttpContext(), | |
// L"iisnode initiated reading http request body chunk and will complete asynchronously", WINEVENT_LEVEL_VERBOSE, context->GetActivityId()); | |
} | |
return; | |
Error: | |
if (HRESULT_FROM_WIN32(ERROR_HANDLE_EOF) == hr) | |
{ | |
context->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(context->GetHttpContext(), | |
L"iisnode detected the end of the http request body", WINEVENT_LEVEL_VERBOSE, context->GetActivityId()); | |
if (context->GetIsUpgrade()) | |
{ | |
CProtocolBridge::FinalizeUpgradeResponse(context, S_OK); | |
} | |
else if (context->GetIsChunked() && !context->GetIsLastChunk()) | |
{ | |
// send the terminating zero-length chunk | |
CProtocolBridge::ReadRequestBodyCompleted(S_OK, 0, context->GetOverlapped()); | |
} | |
else | |
{ | |
CProtocolBridge::StartReadResponse(context); | |
} | |
} | |
else | |
{ | |
context->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(context->GetHttpContext(), | |
L"iisnode failed reading http request body", WINEVENT_LEVEL_ERROR, context->GetActivityId()); | |
if (context->GetIsUpgrade()) | |
{ | |
CProtocolBridge::FinalizeUpgradeResponse(context, HRESULT_FROM_WIN32(hr)); | |
} | |
else | |
{ | |
CProtocolBridge::SendEmptyResponse( context, | |
500, | |
CNodeConstants::IISNODE_ERROR_FAILED_READ_REQ_BODY, | |
_T("Internal Server Error"), | |
HRESULT_FROM_WIN32(hr) ); | |
} | |
} | |
return; | |
} | |
void WINAPI CProtocolBridge::ReadRequestBodyCompleted(DWORD error, DWORD bytesTransfered, LPOVERLAPPED overlapped) | |
{ | |
CNodeHttpStoredContext* ctx = CNodeHttpStoredContext::Get(overlapped); | |
if (S_OK == error && bytesTransfered > 0) | |
{ | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode read a chunk of http request body", WINEVENT_LEVEL_VERBOSE, ctx->GetActivityId()); | |
CProtocolBridge::SendRequestBody(ctx, bytesTransfered); | |
} | |
else if (ERROR_HANDLE_EOF == error || 0 == bytesTransfered) | |
{ | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode detected the end of the http request body", WINEVENT_LEVEL_VERBOSE, ctx->GetActivityId()); | |
if (ctx->GetIsUpgrade()) | |
{ | |
CProtocolBridge::FinalizeUpgradeResponse(ctx, S_OK); | |
} | |
else if (ctx->GetIsChunked() && !ctx->GetIsLastChunk()) | |
{ | |
// send the zero-length last chunk to indicate the end of a chunked entity body | |
CProtocolBridge::SendRequestBody(ctx, 0); | |
} | |
else | |
{ | |
CProtocolBridge::StartReadResponse(ctx); | |
} | |
} | |
else | |
{ | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode failed reading http request body", WINEVENT_LEVEL_ERROR, ctx->GetActivityId()); | |
if (ctx->GetIsUpgrade()) | |
{ | |
CProtocolBridge::FinalizeUpgradeResponse(ctx, error); | |
} | |
else | |
{ | |
CProtocolBridge::SendEmptyResponse( ctx, | |
500, | |
CNodeConstants::IISNODE_ERROR_FAILED_READ_REQ_BODY_COMPLETED, | |
_T("Internal Server Error"), | |
error ); | |
} | |
} | |
} | |
void CProtocolBridge::SendRequestBody(CNodeHttpStoredContext* context, DWORD chunkLength) | |
{ | |
// capture ETW provider since after a successful call to WriteFile the context may be asynchronously deleted | |
CNodeEventProvider* etw = context->GetNodeApplication()->GetApplicationManager()->GetEventProvider(); | |
GUID activityId; | |
memcpy(&activityId, context->GetActivityId(), sizeof GUID); | |
DWORD length; | |
char* buffer; | |
if (context->GetIsChunked()) | |
{ | |
// IIS decodes chunked transfer encoding of request entity body. Chunked encoding must be | |
// re-applied here around the request body data IIS provided in the buffer before it is sent to node.exe. | |
// This is done by calculating and pre-pending the chunk header to the data in the buffer | |
// and appending a chunk terminating CRLF to the data in the buffer. | |
// http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.6 | |
// Generate the chunk header (from last byte to first) | |
buffer = (char*)context->GetChunkBuffer(); // first byte of entity body chunk data | |
*(--buffer) = 0x0A; // LF | |
*(--buffer) = 0x0D; // CR | |
if (0 == chunkLength) | |
{ | |
// this is the end of the request entity body - generate last, zero-length chunk | |
*(--buffer) = '0'; | |
context->SetIsLastChunk(TRUE); | |
} | |
else | |
{ | |
length = chunkLength; | |
while (length > 0) | |
{ | |
DWORD digit = length % 16; | |
*(--buffer) = (digit < 10) ? ('0' + digit) : ('a' + digit - 10); | |
length >>= 4; | |
} | |
} | |
// Append CRLF to the entity body chunk | |
char* end = (char*)context->GetChunkBuffer() + chunkLength; // first byte after the chunk data | |
*end = 0x0D; // CR | |
*(++end) = 0x0A; // LF | |
// Calculate total length of the chunk including framing | |
length = end - buffer + 1; | |
} | |
else | |
{ | |
length = chunkLength; | |
buffer = (char*)context->GetBuffer(); | |
} | |
// send the entity body data to the node.exe process | |
context->SetNextProcessor(CProtocolBridge::SendRequestBodyCompleted); | |
if (WriteFile(context->GetPipe(), (void*)buffer, length, NULL, context->InitializeOverlapped())) | |
{ | |
// completed synchronously | |
etw->Log(context->GetHttpContext(), L"iisnode initiated sending http request body chunk to the node.exe process and completed synchronously", | |
WINEVENT_LEVEL_VERBOSE, | |
&activityId); | |
// despite IO completion ports are used, asynchronous callback will not be invoked because in | |
// CProtocolBridge:CreateNamedPipeConnection the SetFileCompletionNotificationModes function was called | |
// - see http://msdn.microsoft.com/en-us/library/windows/desktop/aa365683(v=vs.85).aspx | |
// and http://msdn.microsoft.com/en-us/library/windows/desktop/aa365538(v=vs.85).aspx | |
CProtocolBridge::SendRequestBodyCompleted(S_OK, 0, context->GetOverlapped()); | |
} | |
else | |
{ | |
HRESULT hr = GetLastError(); | |
if (ERROR_IO_PENDING == hr) | |
{ | |
// will complete asynchronously | |
//etw->Log(context->GetHttpContext(), L"iisnode initiated sending http request body chunk to the node.exe process and will complete asynchronously", | |
// WINEVENT_LEVEL_VERBOSE, | |
// &activityId); | |
} | |
else if (ERROR_NO_DATA == hr) | |
{ | |
// Node.exe has closed the named pipe. This means it does not expect any more request data, but it does not mean there is no response. | |
// This may happen even for POST requests if the node.js application does not register event handlers for the 'data' or 'end' request events. | |
// Ignore the write error and attempt to read the response instead (which might have been written by node.exe before the named pipe connection | |
// was closed). This may also happen for WebSocket traffic. | |
etw->Log(context->GetHttpContext(), L"iisnode detected the node.exe process closed the named pipe connection", | |
WINEVENT_LEVEL_VERBOSE, | |
&activityId); | |
if (context->GetIsUpgrade()) | |
{ | |
CProtocolBridge::FinalizeUpgradeResponse(context, S_OK); | |
} | |
else | |
{ | |
CProtocolBridge::StartReadResponse(context); | |
} | |
} | |
else | |
{ | |
// error | |
etw->Log(context->GetHttpContext(), L"iisnode failed to initiate sending http request body chunk to the node.exe process", | |
WINEVENT_LEVEL_ERROR, | |
&activityId); | |
if (context->GetIsUpgrade()) | |
{ | |
CProtocolBridge::FinalizeUpgradeResponse(context, hr); | |
} | |
else | |
{ | |
CProtocolBridge::SendEmptyResponse( context, | |
500, | |
CNodeConstants::IISNODE_ERROR_FAILED_INIT_SEND_REQ_BODY, | |
_T("Internal Server Error"), | |
hr ); | |
} | |
} | |
} | |
return; | |
} | |
void WINAPI CProtocolBridge::SendRequestBodyCompleted(DWORD error, DWORD bytesTransfered, LPOVERLAPPED overlapped) | |
{ | |
CNodeHttpStoredContext* ctx = CNodeHttpStoredContext::Get(overlapped); | |
if (S_OK == error) | |
{ | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode finished sending http request body chunk to the node.exe process", WINEVENT_LEVEL_VERBOSE, ctx->GetActivityId()); | |
CProtocolBridge::ReadRequestBody(ctx); | |
} | |
else | |
{ | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode failed to send http request body chunk to the node.exe process", WINEVENT_LEVEL_ERROR, ctx->GetActivityId()); | |
if (ctx->GetIsUpgrade()) | |
{ | |
CProtocolBridge::FinalizeUpgradeResponse(ctx, error); | |
} | |
else | |
{ | |
CProtocolBridge::SendEmptyResponse( ctx, | |
500, | |
CNodeConstants::IISNODE_ERROR_FAILED_SEND_REQ_BODY, | |
_T("Internal Server Error"), | |
error ); | |
} | |
} | |
} | |
void CProtocolBridge::StartReadResponse(CNodeHttpStoredContext* context) | |
{ | |
context->SetDataSize(0); | |
context->SetParsingOffset(0); | |
context->SetNextProcessor(CProtocolBridge::ProcessResponseStatusLine); | |
context->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(context->GetHttpContext(), | |
L"iisnode starting to read http response", WINEVENT_LEVEL_VERBOSE, context->GetActivityId()); | |
CProtocolBridge::ContinueReadResponse(context); | |
} | |
HRESULT CProtocolBridge::EnsureBuffer(CNodeHttpStoredContext* context) | |
{ | |
HRESULT hr; | |
if (context->GetBufferSize() == context->GetDataSize()) | |
{ | |
// buffer is full | |
if (context->GetParsingOffset() > 0) | |
{ | |
// remove already parsed data from buffer by moving unprocessed data to the front; this will free up space at the end | |
char* b = (char*)context->GetBuffer(); | |
memcpy(b, b + context->GetParsingOffset(), context->GetDataSize() - context->GetParsingOffset()); | |
} | |
else | |
{ | |
// allocate more buffer memory | |
context->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(context->GetHttpContext(), | |
L"iisnode allocating more buffer memory to handle http response", WINEVENT_LEVEL_VERBOSE, context->GetActivityId()); | |
DWORD* bufferLength = context->GetBufferSizeRef(); | |
void** buffer = context->GetBufferRef(); | |
DWORD quota = CModuleConfiguration::GetMaxRequestBufferSize(context->GetHttpContext()); | |
ErrorIf(*bufferLength >= quota, ERROR_NOT_ENOUGH_QUOTA); | |
void* newBuffer; | |
DWORD newBufferLength = *bufferLength * 2; | |
if (newBufferLength > quota) | |
{ | |
newBufferLength = quota; | |
} | |
ErrorIf(NULL == (newBuffer = context->GetHttpContext()->AllocateRequestMemory(newBufferLength)), ERROR_NOT_ENOUGH_MEMORY); | |
memcpy(newBuffer, (char*)(*buffer) + context->GetParsingOffset(), context->GetDataSize() - context->GetParsingOffset()); | |
*buffer = newBuffer; | |
*bufferLength = newBufferLength; | |
} | |
context->SetDataSize(context->GetDataSize() - context->GetParsingOffset()); | |
context->SetParsingOffset(0); | |
} | |
return S_OK; | |
Error: | |
return hr; | |
} | |
void CProtocolBridge::ContinueReadResponse(CNodeHttpStoredContext* context) | |
{ | |
HRESULT hr; | |
DWORD bytesRead = 0; | |
// capture ETW provider since after a successful call to ReadFile the context may be asynchronously deleted | |
CNodeEventProvider* etw = context->GetNodeApplication()->GetApplicationManager()->GetEventProvider(); | |
GUID activityId; | |
memcpy(&activityId, context->GetActivityId(), sizeof GUID); | |
CheckError(CProtocolBridge::EnsureBuffer(context)); | |
if (ReadFile( | |
context->GetPipe(), | |
(char*)context->GetBuffer() + context->GetDataSize(), | |
context->GetBufferSize() - context->GetDataSize(), | |
&bytesRead, | |
context->InitializeOverlapped())) | |
{ | |
// read completed synchronously | |
etw->Log(context->GetHttpContext(), L"iisnode initiated reading http response chunk and completed synchronously", | |
WINEVENT_LEVEL_VERBOSE, | |
&activityId); | |
// despite IO completion ports are used, asynchronous callback will not be invoked because in | |
// CProtocolBridge:CreateNamedPipeConnection the SetFileCompletionNotificationModes function was called | |
// - see http://msdn.microsoft.com/en-us/library/windows/desktop/aa365683(v=vs.85).aspx | |
// and http://msdn.microsoft.com/en-us/library/windows/desktop/aa365538(v=vs.85).aspx | |
context->GetAsyncContext()->completionProcessor(S_OK, bytesRead, context->GetOverlapped()); | |
} | |
else if (ERROR_IO_PENDING == (hr = GetLastError())) | |
{ | |
// read will complete asynchronously | |
//etw->Log(context->GetHttpContext(), L"iisnode initiated reading http response chunk and will complete asynchronously", | |
// WINEVENT_LEVEL_VERBOSE, | |
// &activityId); | |
} | |
else if (ERROR_BROKEN_PIPE == hr && context->GetCloseConnection()) | |
{ | |
// Termination of a connection indicates the end of the response body if Connection: close response header was present | |
CProtocolBridge::FinalizeResponse(context); | |
} | |
else | |
{ | |
// error | |
etw->Log(context->GetHttpContext(), L"iisnode failed to initialize reading of http response chunk", | |
WINEVENT_LEVEL_ERROR, | |
&activityId); | |
CProtocolBridge::SendEmptyResponse( context, | |
500, | |
CNodeConstants::IISNODE_ERROR_FAILED_INIT_READ_RESPONSE, | |
_T("Internal Server Error"), | |
hr ); | |
} | |
return; | |
Error: | |
context->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(context->GetHttpContext(), | |
L"iisnode failed to allocate memory buffer to read http response chunk", WINEVENT_LEVEL_ERROR, &activityId); | |
CProtocolBridge::SendEmptyResponse( context, | |
500, | |
CNodeConstants::IISNODE_ERROR_FAILED_ALLOC_MEM_READ_RESPONSE, | |
_T("Internal Server Error"), | |
hr ); | |
return; | |
} | |
void WINAPI CProtocolBridge::ProcessResponseStatusLine(DWORD error, DWORD bytesTransfered, LPOVERLAPPED overlapped) | |
{ | |
HRESULT hr; | |
CNodeHttpStoredContext* ctx = CNodeHttpStoredContext::Get(overlapped); | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode starting to process http response status line", WINEVENT_LEVEL_VERBOSE, ctx->GetActivityId()); | |
CheckError(error); | |
ctx->SetDataSize(ctx->GetDataSize() + bytesTransfered); | |
CheckError(CHttpProtocol::ParseResponseStatusLine(ctx)); | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode finished processing http response status line", WINEVENT_LEVEL_VERBOSE, ctx->GetActivityId()); | |
ctx->SetNextProcessor(CProtocolBridge::ProcessResponseHeaders); | |
CProtocolBridge::ProcessResponseHeaders(S_OK, 0, ctx->GetOverlapped()); | |
return; | |
Error: | |
if (ERROR_MORE_DATA == hr) | |
{ | |
CProtocolBridge::ContinueReadResponse(ctx); | |
} | |
else | |
{ | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode failed to process http response status line", WINEVENT_LEVEL_ERROR, ctx->GetActivityId()); | |
CProtocolBridge::SendEmptyResponse( ctx, | |
500, | |
CNodeConstants::IISNODE_ERROR_FAILED_PROCESS_HTTP_STATUS_LINE, | |
_T("Internal Server Error"), | |
hr ); | |
} | |
return; | |
} | |
HRESULT CProtocolBridge::AddDebugHeader(CNodeHttpStoredContext* context) | |
{ | |
HRESULT hr; | |
char* header; | |
char buffer[256]; | |
ErrorIf(NULL == (header = (char*)context->GetHttpContext()->AllocateRequestMemory(512)), ERROR_NOT_ENOUGH_MEMORY); | |
*header = 0; | |
// iisnode version | |
strcat(header, "http://bit.ly/NsU2nd#iisnode_ver="); | |
strcat(header, IISNODE_VERSION); | |
// node process command line | |
WCHAR* npcl = CModuleConfiguration::GetNodeProcessCommandLine(context->GetHttpContext()); | |
size_t npcl_length = wcslen(npcl) + 1; | |
char* npcl_c; | |
ErrorIf(NULL == (npcl_c = (char*)context->GetHttpContext()->AllocateRequestMemory(npcl_length)), ERROR_NOT_ENOUGH_MEMORY); | |
size_t converted; | |
wcstombs_s(&converted, npcl_c, npcl_length, npcl, _TRUNCATE); | |
strcat(header, "&node="); | |
strcat(header, npcl_c); | |
// dns name | |
DWORD length = sizeof buffer; | |
if (GetComputerNameEx(ComputerNameDnsFullyQualified, buffer, &length)) | |
{ | |
strcat(header, "&dns="); | |
strcat(header, buffer); | |
} | |
// worker PID | |
sprintf(buffer, "&worker_pid=%d", GetCurrentProcessId()); | |
strcat(header, buffer); | |
// node PID | |
sprintf(buffer, "&node_pid=%d", context->GetNodeProcess()->GetPID()); | |
strcat(header, buffer); | |
// worker working set and private bytes | |
PROCESS_MEMORY_COUNTERS_EX memory; | |
ErrorIf(!GetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS*)&memory, sizeof memory), GetLastError()); | |
sprintf(buffer, "&worker_mem_ws=%u&worker_mem_pagefile=%u", memory.WorkingSetSize / 1024, memory.PagefileUsage / 1024); | |
strcat(header, buffer); | |
// node working set and private bytes | |
ErrorIf(!GetProcessMemoryInfo(context->GetNodeProcess()->GetProcess(), (PROCESS_MEMORY_COUNTERS*)&memory, sizeof memory), GetLastError()); | |
sprintf(buffer, "&node_mem_ws=%u&node_mem_pagefile=%u", memory.WorkingSetSize / 1024, memory.PagefileUsage / 1024); | |
strcat(header, buffer); | |
// number of processes | |
sprintf(buffer, "&app_processes=%d", context->GetNodeApplication()->GetProcessCount()); | |
strcat(header, buffer); | |
// process active requests | |
sprintf(buffer, "&process_active_req=%d", context->GetNodeProcess()->GetActiveRequestCount()); | |
strcat(header, buffer); | |
// application active requests | |
sprintf(buffer, "&app_active_req=%d", context->GetNodeApplication()->GetActiveRequestCount()); | |
strcat(header, buffer); | |
// worker total requests | |
sprintf(buffer, "&worker_total_req=%d", context->GetNodeApplication()->GetApplicationManager()->GetTotalRequests()); | |
strcat(header, buffer); | |
// named pipe reconnect attempts | |
sprintf(buffer, "&np_retry=%d", context->GetConnectionRetryCount()); | |
strcat(header, buffer); | |
// request time | |
FILETIME endTime; | |
GetSystemTimeAsFileTime(&endTime); | |
ULARGE_INTEGER start, end; | |
start.HighPart = context->GetStartTime()->dwHighDateTime; | |
start.LowPart = context->GetStartTime()->dwLowDateTime; | |
end.HighPart = endTime.dwHighDateTime; | |
end.LowPart = endTime.dwLowDateTime; | |
end.QuadPart -= start.QuadPart; | |
end.QuadPart /= 10000; // convert to milliseconds | |
sprintf(buffer, "&req_time=%u", end.LowPart); | |
strcat(header, buffer); | |
// hresult | |
sprintf(buffer, "&hresult=%d", context->GetHresult()); | |
strcat(header, buffer); | |
// add header | |
CheckError(context->GetHttpContext()->GetResponse()->SetHeader("iisnode-debug", header, strlen(header), TRUE)); | |
return S_OK; | |
Error: | |
return hr; | |
} | |
void WINAPI CProtocolBridge::ProcessResponseHeaders(DWORD error, DWORD bytesTransfered, LPOVERLAPPED overlapped) | |
{ | |
HRESULT hr; | |
CNodeHttpStoredContext* ctx = CNodeHttpStoredContext::Get(overlapped); | |
PCSTR contentLength; | |
USHORT contentLengthLength; | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode starting to process http response headers", WINEVENT_LEVEL_VERBOSE, ctx->GetActivityId()); | |
CheckError(error); | |
ctx->SetDataSize(ctx->GetDataSize() + bytesTransfered); | |
CheckError(CHttpProtocol::ParseResponseHeaders(ctx)); | |
if (CModuleConfiguration::GetDebugHeaderEnabled(ctx->GetHttpContext())) | |
{ | |
CheckError(CProtocolBridge::AddDebugHeader(ctx)); | |
} | |
if (!ctx->GetExpectResponseBody()) | |
{ | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode determined the HTTP response does not have entity body", WINEVENT_LEVEL_VERBOSE, ctx->GetActivityId()); | |
CProtocolBridge::FinalizeResponse(ctx); | |
} | |
else | |
{ | |
if (ctx->GetIsUpgrade()) | |
{ | |
ctx->SetIsChunked(FALSE); | |
ctx->SetChunkLength(MAXLONGLONG); | |
ctx->SetIsLastChunk(TRUE); | |
ctx->SetNextProcessor(CProtocolBridge::ProcessUpgradeResponse); | |
} | |
else if (ctx->GetCloseConnection()) | |
{ | |
ctx->SetIsChunked(FALSE); | |
ctx->SetChunkLength(MAXLONGLONG); | |
ctx->SetIsLastChunk(TRUE); | |
ctx->SetNextProcessor(CProtocolBridge::ProcessResponseBody); | |
} | |
else | |
{ | |
contentLength = ctx->GetHttpContext()->GetResponse()->GetHeader(HttpHeaderContentLength, &contentLengthLength); | |
if (0 == contentLengthLength) | |
{ | |
ctx->SetIsChunked(TRUE); | |
ctx->SetIsLastChunk(FALSE); | |
ctx->SetNextProcessor(CProtocolBridge::ProcessChunkHeader); | |
} | |
else | |
{ | |
LONGLONG length = 0; | |
int i = 0; | |
// skip leading white space | |
while (i < contentLengthLength && (contentLength[i] < '0' || contentLength[i] > '9')) | |
i++; | |
while (i < contentLengthLength && contentLength[i] >= '0' && contentLength[i] <= '9') | |
length = length * 10 + contentLength[i++] - '0'; | |
ctx->SetIsChunked(FALSE); | |
ctx->SetIsLastChunk(TRUE); | |
ctx->SetChunkLength(length); | |
ctx->SetNextProcessor(CProtocolBridge::ProcessResponseBody); | |
} | |
} | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode finished processing http response headers", WINEVENT_LEVEL_VERBOSE, ctx->GetActivityId()); | |
ctx->GetAsyncContext()->completionProcessor(S_OK, 0, ctx->GetOverlapped()); | |
} | |
return; | |
Error: | |
if (ERROR_MORE_DATA == hr) | |
{ | |
CProtocolBridge::ContinueReadResponse(ctx); | |
} | |
else | |
{ | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode failed to process http response headers", WINEVENT_LEVEL_ERROR, ctx->GetActivityId()); | |
CProtocolBridge::SendEmptyResponse( ctx, | |
500, | |
CNodeConstants::IISNODE_ERROR_FAILED_PROCESS_HTTP_HEADERS, | |
_T("Internal Server Error"), | |
hr ); | |
} | |
return; | |
} | |
void WINAPI CProtocolBridge::ProcessChunkHeader(DWORD error, DWORD bytesTransfered, LPOVERLAPPED overlapped) | |
{ | |
HRESULT hr; | |
CNodeHttpStoredContext* ctx = CNodeHttpStoredContext::Get(overlapped); | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode starting to process http response body chunk header", WINEVENT_LEVEL_VERBOSE, ctx->GetActivityId()); | |
CheckError(error); | |
ctx->SetDataSize(ctx->GetDataSize() + bytesTransfered); | |
CheckError(CHttpProtocol::ParseChunkHeader(ctx)); | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode finished processing http response body chunk header", WINEVENT_LEVEL_VERBOSE, ctx->GetActivityId()); | |
ctx->SetNextProcessor(CProtocolBridge::ProcessResponseBody); | |
CProtocolBridge::ProcessResponseBody(S_OK, 0, ctx->GetOverlapped()); | |
return; | |
Error: | |
if (ERROR_MORE_DATA == hr) | |
{ | |
CProtocolBridge::ContinueReadResponse(ctx); | |
} | |
else | |
{ | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode failed to process response body chunk header", WINEVENT_LEVEL_ERROR, ctx->GetActivityId()); | |
CProtocolBridge::SendEmptyResponse( ctx, | |
500, | |
CNodeConstants::IISNODE_ERROR_FAILED_PROCESS_RESPONSE_BODY_CHUNK_HEADER, | |
_T("Internal Server Error"), | |
hr ); | |
} | |
return; | |
} | |
void CProtocolBridge::EnsureRequestPumpStarted(CNodeHttpStoredContext* context) | |
{ | |
if (context->GetOpaqueFlagSet() && !context->GetRequestPumpStarted()) | |
{ | |
// Ensure that we start reading the request of an HTTP Upgraded request | |
// only after the 101 Switching Protocols response had been sent. | |
context->SetRequestPumpStarted(); | |
CProtocolBridge::ReadRequestBody(context->GetUpgradeContext()); | |
ASYNC_CONTEXT* async = context->GetUpgradeContext()->GetAsyncContext(); | |
async->RunSynchronousContinuations(); | |
} | |
} | |
void WINAPI CProtocolBridge::ProcessResponseBody(DWORD error, DWORD bytesTransfered, LPOVERLAPPED overlapped) | |
{ | |
HRESULT hr; | |
CNodeHttpStoredContext* ctx = CNodeHttpStoredContext::Get(overlapped); | |
HTTP_DATA_CHUNK* chunk; | |
DWORD bytesSent; | |
BOOL completionExpected; | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode starting to process http response body", WINEVENT_LEVEL_VERBOSE, ctx->GetActivityId()); | |
CheckError(error); | |
ctx->SetDataSize(ctx->GetDataSize() + bytesTransfered); | |
if (ctx->GetDataSize() > ctx->GetParsingOffset()) | |
{ | |
// there is response body data in the buffer | |
if (ctx->GetChunkLength() > ctx->GetChunkTransmitted()) | |
{ | |
// send the smaller of the rest of the current chunk or the data available in the buffer to the client | |
DWORD dataInBuffer = ctx->GetDataSize() - ctx->GetParsingOffset(); | |
DWORD remainingChunkSize = ctx->GetChunkLength() - ctx->GetChunkTransmitted(); | |
DWORD bytesToSend = dataInBuffer < remainingChunkSize ? dataInBuffer : remainingChunkSize; | |
CheckError(ctx->EnsureResponseChunk(bytesToSend, &chunk)); | |
chunk->FromMemory.BufferLength = bytesToSend; | |
memcpy(chunk->FromMemory.pBuffer, (char*)ctx->GetBuffer() + ctx->GetParsingOffset(), chunk->FromMemory.BufferLength); | |
if (bytesToSend == dataInBuffer) | |
{ | |
ctx->SetDataSize(0); | |
ctx->SetParsingOffset(0); | |
} | |
else | |
{ | |
ctx->SetParsingOffset(ctx->GetParsingOffset() + bytesToSend); | |
} | |
ctx->SetNextProcessor(CProtocolBridge::SendResponseBodyCompleted); | |
ctx->SetBytesCompleted(bytesToSend); | |
CheckError(ctx->GetHttpContext()->GetResponse()->WriteEntityChunks( | |
chunk, | |
1, | |
TRUE, | |
!ctx->GetIsLastChunk() || remainingChunkSize > bytesToSend, | |
&bytesSent, | |
&completionExpected)); | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode started sending http response body chunk", WINEVENT_LEVEL_VERBOSE, ctx->GetActivityId()); | |
if (!completionExpected) | |
{ | |
ctx->SetContinueSynchronously(TRUE); | |
} | |
} | |
else if (ctx->GetIsChunked()) | |
{ | |
// process next chunk of the chunked encoding | |
ctx->SetNextProcessor(CProtocolBridge::ProcessChunkHeader); | |
CProtocolBridge::ProcessChunkHeader(S_OK, 0, ctx->GetOverlapped()); | |
} | |
else | |
{ | |
// response data detected beyond the body length declared with Content-Length | |
CheckError(ERROR_BAD_FORMAT); | |
} | |
} | |
else if (ctx->GetIsChunked() || ctx->GetChunkLength() > ctx->GetChunkTransmitted()) | |
{ | |
// read more body data | |
CProtocolBridge::ContinueReadResponse(ctx); | |
} | |
else | |
{ | |
// finish request | |
if (ctx->GetIsUpgrade()) | |
{ | |
CProtocolBridge::FinalizeUpgradeResponse(ctx, S_OK); | |
} | |
else | |
{ | |
CProtocolBridge::FinalizeResponse(ctx); | |
} | |
} | |
return; | |
Error: | |
if (ERROR_BROKEN_PIPE == hr && ctx->GetIsUpgrade()) | |
{ | |
// Termination of a connection indicates the end of the upgraded request | |
CProtocolBridge::FinalizeUpgradeResponse(ctx, S_OK); | |
} | |
else if (ERROR_BROKEN_PIPE == hr && ctx->GetCloseConnection()) | |
{ | |
// Termination of a connection indicates the end of the response body if Connection: close response header was present | |
CProtocolBridge::FinalizeResponse(ctx); | |
} | |
else | |
{ | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode failed to send http response body chunk", WINEVENT_LEVEL_ERROR, ctx->GetActivityId()); | |
if (ctx->GetIsUpgrade()) | |
{ | |
CProtocolBridge::FinalizeUpgradeResponse(ctx, hr); | |
} | |
else | |
{ | |
CProtocolBridge::SendEmptyResponse( ctx, | |
500, | |
CNodeConstants::IISNODE_ERROR_FAILED_SEND_RESPONSE_BODY_CHUNK, | |
_T("Internal Server Error"), | |
hr ); | |
} | |
} | |
return; | |
} | |
void WINAPI CProtocolBridge::SendResponseBodyCompleted(DWORD error, DWORD bytesTransfered, LPOVERLAPPED overlapped) | |
{ | |
HRESULT hr; | |
CNodeHttpStoredContext* ctx = CNodeHttpStoredContext::Get(overlapped); | |
DWORD bytesSent; | |
BOOL completionExpected = FALSE; | |
CheckError(error); | |
if (!ctx->GetIsUpgrade()) | |
{ | |
ctx->SetChunkTransmitted(ctx->GetChunkTransmitted() + bytesTransfered); | |
if (ctx->GetChunkLength() == ctx->GetChunkTransmitted()) | |
{ | |
ctx->SetChunkTransmitted(0); | |
ctx->SetChunkLength(0); | |
} | |
} | |
if (ctx->GetIsLastChunk() && ctx->GetChunkLength() == ctx->GetChunkTransmitted()) | |
{ | |
CProtocolBridge::FinalizeResponse(ctx); | |
} | |
else | |
{ | |
if (ctx->GetIsChunked() && CModuleConfiguration::GetFlushResponse(ctx->GetHttpContext())) | |
{ | |
// Flushing of chunked responses is enabled | |
ctx->SetNextProcessor(CProtocolBridge::ContinueProcessResponseBodyAfterPartialFlush); | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode initiated flushing http response body chunk", WINEVENT_LEVEL_VERBOSE, ctx->GetActivityId()); | |
ctx->GetHttpContext()->GetResponse()->Flush(TRUE, TRUE, &bytesSent, &completionExpected); | |
} | |
if (!completionExpected) | |
{ | |
CProtocolBridge::ContinueProcessResponseBodyAfterPartialFlush(S_OK, 0, ctx->GetOverlapped()); | |
} | |
} | |
return; | |
Error: | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode failed to flush http response body chunk", WINEVENT_LEVEL_ERROR, ctx->GetActivityId()); | |
if (ctx->GetIsUpgrade()) | |
{ | |
CProtocolBridge::FinalizeUpgradeResponse(ctx, hr); | |
} | |
else | |
{ | |
CProtocolBridge::SendEmptyResponse( ctx, | |
500, | |
CNodeConstants::IISNODE_ERROR_FAILED_FLUSH_RESPONSE_BODY, | |
_T("Internal Server Error"), | |
hr ); | |
} | |
return; | |
} | |
void WINAPI CProtocolBridge::ProcessUpgradeResponse(DWORD error, DWORD bytesTransfered, LPOVERLAPPED overlapped) | |
{ | |
BOOL completionExpected; | |
DWORD bytesSent; | |
CNodeHttpStoredContext* ctx = CNodeHttpStoredContext::Get(overlapped); | |
ctx->SetNextProcessor(CProtocolBridge::ContinueProcessResponseBodyAfterPartialFlush); | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode initiated flushing http upgrade response headers", WINEVENT_LEVEL_VERBOSE, ctx->GetActivityId()); | |
ctx->GetHttpContext()->GetResponse()->Flush(TRUE, TRUE, &bytesSent, &completionExpected); | |
if (!completionExpected) | |
{ | |
CProtocolBridge::ContinueProcessResponseBodyAfterPartialFlush(S_OK, 0, ctx->GetOverlapped()); | |
} | |
} | |
void WINAPI CProtocolBridge::ContinueProcessResponseBodyAfterPartialFlush(DWORD error, DWORD bytesTransfered, LPOVERLAPPED overlapped) | |
{ | |
HRESULT hr; | |
CNodeHttpStoredContext* ctx = CNodeHttpStoredContext::Get(overlapped); | |
CheckError(error); | |
// Start reading the request bytes if the request was an accepted HTTP Upgrade | |
CProtocolBridge::EnsureRequestPumpStarted(ctx); | |
// Continue on to reading the response body | |
ctx->SetNextProcessor(CProtocolBridge::ProcessResponseBody); | |
CProtocolBridge::ProcessResponseBody(S_OK, 0, ctx->GetOverlapped()); | |
return; | |
Error: | |
ctx->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(ctx->GetHttpContext(), | |
L"iisnode failed to flush http response body chunk", WINEVENT_LEVEL_ERROR, ctx->GetActivityId()); | |
CProtocolBridge::SendEmptyResponse( ctx, | |
500, | |
CNodeConstants::IISNODE_ERROR_FAILED_FLUSH_RESPONSE_BODY_PARTIAL_FLUSH, | |
_T("Internal Server Error"), | |
hr ); | |
return; | |
} | |
void CProtocolBridge::FinalizeUpgradeResponse(CNodeHttpStoredContext* context, HRESULT hresult) | |
{ | |
context->SetNextProcessor(NULL); | |
context->SetHresult(hresult); | |
if (0 == context->DecreasePendingAsyncOperationCount()) | |
{ | |
context->GetNodeProcess()->OnRequestCompleted(context); | |
context->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(context->GetHttpContext(), | |
L"iisnode finished processing both directions of upgraded http request/response", WINEVENT_LEVEL_VERBOSE, context->GetActivityId()); | |
context->SetRequestNotificationStatus(RQ_NOTIFICATION_CONTINUE); | |
CloseHandle(context->GetPipe()); | |
context->SetPipe(INVALID_HANDLE_VALUE); | |
context->GetHttpContext()->GetResponse()->SetNeedDisconnect(); | |
context->GetHttpContext()->PostCompletion(0); | |
} | |
else | |
{ | |
context->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(context->GetHttpContext(), | |
L"iisnode finished processing one direction of upgraded http request/response", WINEVENT_LEVEL_VERBOSE, context->GetActivityId()); | |
context->SetRequestNotificationStatus(RQ_NOTIFICATION_PENDING); | |
} | |
} | |
void CProtocolBridge::FinalizeResponse(CNodeHttpStoredContext* context) | |
{ | |
context->GetNodeApplication()->GetApplicationManager()->GetEventProvider()->Log(context->GetHttpContext(), | |
L"iisnode finished processing http request/response", WINEVENT_LEVEL_VERBOSE, context->GetActivityId()); | |
if (context->GetCloseConnection()) | |
{ | |
CloseHandle(context->GetPipe()); | |
} | |
else | |
{ | |
context->GetNodeProcess()->GetConnectionPool()->Return(context->GetPipe()); | |
} | |
context->SetPipe(INVALID_HANDLE_VALUE); | |
CProtocolBridge::FinalizeResponseCore( | |
context, | |
RQ_NOTIFICATION_CONTINUE, | |
S_OK, | |
context->GetNodeApplication()->GetApplicationManager()->GetEventProvider(), | |
L"iisnode posts completion from FinalizeResponse", | |
WINEVENT_LEVEL_VERBOSE); | |
} | |
HRESULT CProtocolBridge::FinalizeResponseCore(CNodeHttpStoredContext* context, REQUEST_NOTIFICATION_STATUS status, HRESULT error, CNodeEventProvider* log, PCWSTR etw, UCHAR level) | |
{ | |
context->SetRequestNotificationStatus(status); | |
context->SetNextProcessor(NULL); | |
context->SetHresult(error); | |
if (NULL != context->GetNodeProcess()) | |
{ | |
// there is no CNodeProcess assigned to the request yet - something failed before it was moved from the pending queue | |
// to an active request queue of a specific process | |
context->GetNodeProcess()->OnRequestCompleted(context); | |
} | |
if (0 == context->DecreasePendingAsyncOperationCount()) // decreases ref count increased in the ctor of CNodeApplication::Dispatch | |
{ | |
log->Log(etw, level, context->GetActivityId()); | |
context->GetHttpContext()->PostCompletion(0); | |
} | |
return S_OK; | |
} | |
HRESULT CProtocolBridge::SendDebugRedirect(CNodeHttpStoredContext* context, CNodeEventProvider* log) | |
{ | |
HRESULT hr; | |
IHttpContext* ctx = context->GetHttpContext(); | |
IHttpResponse* response = ctx->GetResponse(); | |
HTTP_REQUEST* raw = ctx->GetRequest()->GetRawHttpRequest(); | |
// redirect app.js/debug to app.js/debug/ by appending '/' at the end of the path | |
PSTR path; | |
int pathSizeA; | |
ErrorIf(0 == (pathSizeA = WideCharToMultiByte(CP_ACP, 0, raw->CookedUrl.pAbsPath, raw->CookedUrl.AbsPathLength >> 1, NULL, 0, NULL, NULL)), E_FAIL); | |
ErrorIf(NULL == (path = (TCHAR*)ctx->AllocateRequestMemory(pathSizeA + 2)), ERROR_NOT_ENOUGH_MEMORY); | |
ErrorIf(pathSizeA != WideCharToMultiByte(CP_ACP, 0, raw->CookedUrl.pAbsPath, raw->CookedUrl.AbsPathLength >> 1, path, pathSizeA, NULL, NULL), E_FAIL); | |
path[pathSizeA] = '/'; | |
path[pathSizeA + 1] = 0; | |
response->SetStatus(301, "Moved Permanently"); | |
CheckError(context->GetHttpContext()->GetResponse()->Redirect(path, FALSE, TRUE)); | |
CProtocolBridge::FinalizeResponseCore( | |
context, | |
RQ_NOTIFICATION_FINISH_REQUEST, | |
S_OK, | |
log, | |
L"iisnode redirected debugging request", | |
WINEVENT_LEVEL_VERBOSE); | |
return S_OK; | |
Error: | |
return hr; | |
} |