BOOL _CreateProcessExA(HANDLE hToken, DWORD dwLogonFlags,
LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation)
{
pid_t pid;
int numArgs;
LPSTR* pArgs = NULL;
char** envp = NULL;
char* filename = NULL;
HANDLE thread;
HANDLE process;
WINPR_ACCESS_TOKEN* token;
LPTCH lpszEnvironmentBlock;
BOOL ret = FALSE;
sigset_t oldSigMask;
sigset_t newSigMask;
BOOL restoreSigMask = FALSE;
numArgs = 0;
lpszEnvironmentBlock = NULL;
pArgs = CommandLineToArgvA(lpCommandLine, &numArgs);
if (!pArgs)
return FALSE;
token = (WINPR_ACCESS_TOKEN*) hToken;
if (lpEnvironment)
{
envp = EnvironmentBlockToEnvpA(lpEnvironment);
}
else
{
lpszEnvironmentBlock = GetEnvironmentStrings();
if (!lpszEnvironmentBlock)
goto finish;
envp = EnvironmentBlockToEnvpA(lpszEnvironmentBlock);
}
if (!envp)
goto finish;
filename = FindApplicationPath(pArgs[0]);
if (NULL == filename)
goto finish;
/* block all signals so that the child can safely reset the caller's handlers */
sigfillset(&newSigMask);
restoreSigMask = !pthread_sigmask(SIG_SETMASK, &newSigMask, &oldSigMask);
/* fork and exec */
pid = fork();
if (pid < 0)
{
/* fork failure */
goto finish;
}
if (pid == 0)
{
/* child process */
#ifndef __sun
int maxfd;
#endif
int fd;
int sig;
sigset_t set;
struct sigaction act;
/* set default signal handlers */
memset(&act, 0, sizeof(act));
act.sa_handler = SIG_DFL;
act.sa_flags = 0;
sigemptyset(&act.sa_mask);
for (sig = 1; sig < NSIG; sig++)
sigaction(sig, &act, NULL);
/* unblock all signals */
sigfillset(&set);
pthread_sigmask(SIG_UNBLOCK, &set, NULL);
if (lpStartupInfo)
{
int handle_fd;
handle_fd = winpr_Handle_getFd(lpStartupInfo->hStdOutput);
if (handle_fd != -1)
dup2(handle_fd, STDOUT_FILENO);
handle_fd = winpr_Handle_getFd(lpStartupInfo->hStdError);
if (handle_fd != -1)
dup2(handle_fd, STDERR_FILENO);
handle_fd = winpr_Handle_getFd(lpStartupInfo->hStdInput);
if (handle_fd != -1)
dup2(handle_fd, STDIN_FILENO);
}
#ifdef __sun
closefrom(3);
#else
#ifdef F_MAXFD // on some BSD derivates
maxfd = fcntl(0, F_MAXFD);
#else
maxfd = sysconf(_SC_OPEN_MAX);
#endif
for (fd = 3; fd < maxfd; fd++)
close(fd);
#endif // __sun
if (token)
{
if (token->GroupId)
{
int rc = setgid((gid_t) token->GroupId);
if (rc < 0)
{
}
else
{
initgroups(token->Username, (gid_t) token->GroupId);
}
}
if (token->UserId)
setuid((uid_t) token->UserId);
}
/* TODO: add better cwd handling and error checking */
if (lpCurrentDirectory && strlen(lpCurrentDirectory) > 0)
chdir(lpCurrentDirectory);
if (execve(filename, pArgs, envp) < 0)
{
/* execve failed - end the process */
_exit(1);
}
}
else
{
/* parent process */
}
process = CreateProcessHandle(pid);
if (!process)
{
goto finish;
}
thread = CreateNoneHandle();
if (!thread)
{
ProcessHandleCloseHandle(process);
goto finish;
}
lpProcessInformation->hProcess = process;
lpProcessInformation->hThread = thread;
lpProcessInformation->dwProcessId = (DWORD) pid;
lpProcessInformation->dwThreadId = (DWORD) pid;
ret = TRUE;
finish:
/* restore caller's original signal mask */
if (restoreSigMask)
pthread_sigmask(SIG_SETMASK, &oldSigMask, NULL);
free(filename);
if (pArgs)
{
HeapFree(GetProcessHeap(), 0, pArgs);
}
if (lpszEnvironmentBlock)
FreeEnvironmentStrings(lpszEnvironmentBlock);
if (envp)
{
int i = 0;
while (envp[i])
{
free(envp[i]);
i++;
}
free(envp);
}
return ret;
}
// Function name : RunLocal
// Description :
// Return type : void
// Argument : bool bDoSMP
void RunLocal(bool bDoSMP)
{
DWORD size = 100;
TCHAR pszHost[100], pszCmdLine[MAX_PATH], error_msg[256], pszEnv[256], pszExtra[MAX_PATH];
STARTUPINFO saInfo;
PROCESS_INFORMATION psInfo;
LPTSTR pEnv;
int rootPort=0;
HANDLE *hProcess = new HANDLE[g_nHosts];
GetComputerName(pszHost, &size);
wsprintf(pszCmdLine, TEXT("%s %s"), g_pszExe, g_pszArgs);
GetTempFileName(_T("."), _T("mpi"), 0, pszExtra);
// This produces a name in the form: ".\XXXmpi.tmp"
// \ is illegal in named objects so use &pszExtra[2] instead of pszExtra for the JobID
if (bDoSMP)
{
wsprintf(pszEnv, _T("MPICH_JOBID=%s|MPICH_IPROC=0|MPICH_NPROC=%d|MPICH_ROOTHOST=%s|MPICH_ROOTPORT=%d|MPICH_EXTRA=%s|MPICH_COMNIC=%s|MPICH_SHM_LOW=0|MPICH_SHM_HIGH=%d"),
&pszExtra[2], g_nHosts, pszHost, -1, pszExtra, pszHost, g_nHosts-1);
}
else
{
wsprintf(pszEnv, _T("MPICH_JOBID=%s|MPICH_IPROC=0|MPICH_NPROC=%d|MPICH_ROOTHOST=%s|MPICH_ROOTPORT=%d|MPICH_EXTRA=%s|MPICH_COMNIC=%s"),
&pszExtra[2], g_nHosts, pszHost, -1, pszExtra, pszHost);
}
SetEnvironmentVariables(pszEnv);
if (_tcslen(g_pszEnv) > 0)
SetEnvironmentVariables(g_pszEnv);
pEnv = GetEnvironmentStrings();
GetStartupInfo(&saInfo);
// launch first process
if (CreateProcess(
NULL,
pszCmdLine,
NULL, NULL, FALSE,
IDLE_PRIORITY_CLASS,
pEnv,
NULL,
&saInfo, &psInfo))
{
hProcess[0] = psInfo.hProcess;
CloseHandle(psInfo.hThread);
}
else
{
int error = GetLastError();
Translate_Error(error, error_msg, TEXT("CreateProcess failed: "));
_tprintf(TEXT("Unable to launch '%s', error %d: %s"), pszCmdLine, error, error_msg);
return;
}
RemoveEnvironmentVariables(pszEnv);
FreeEnvironmentStrings(pEnv);
if (g_bNoMPI)
{
rootPort = -1;
}
else
{
// Open the file and read the port number written by the first process
HANDLE hFile = CreateFile(pszExtra, GENERIC_READ, FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
Translate_Error(GetLastError(), error_msg, TEXT("CreateFile failed "));
_tprintf(error_msg);
return;
}
DWORD num_read = 0;
TCHAR pBuffer[100];
pBuffer[0] = '\0';
TCHAR *pChar = pBuffer;
clock_t cStart = clock();
while (true)
{
num_read = 0;
if (!ReadFile(hFile, pChar, 100, &num_read, NULL))
{
Translate_Error(GetLastError(), error_msg, TEXT("ReadFile failed "));
_tprintf(error_msg);
return;
}
if (num_read == 0)
{
if (clock() - cStart > 10 * CLOCKS_PER_SEC)
{
_tprintf(TEXT("Wait for process 0 to write port to temporary file timed out\n"));
TerminateProcess(hProcess, 0);
return;
}
Sleep(100);
}
else
{
for (int i=0; i<(int)num_read; i++)
{
if (*pChar == _T('\n'))
break;
pChar ++;
}
if (*pChar == _T('\n'))
break;
}
}
CloseHandle(hFile);
rootPort = _ttoi(pBuffer);
}
DeleteFile(pszExtra);
// launch all the rest of the processes
for (int i=1; i<g_nHosts; i++)
{
if (bDoSMP)
{
wsprintf(pszEnv, _T("MPICH_JOBID=%s|MPICH_IPROC=%d|MPICH_NPROC=%d|MPICH_ROOTHOST=%s|MPICH_ROOTPORT=%d|MPICH_COMNIC=%s|MPICH_SHM_LOW=0|MPICH_SHM_HIGH=%d"),
&pszExtra[2], i, g_nHosts, pszHost, rootPort, pszHost, g_nHosts-1);
}
else
{
wsprintf(pszEnv, _T("MPICH_JOBID=%s|MPICH_IPROC=%d|MPICH_NPROC=%d|MPICH_ROOTHOST=%s|MPICH_ROOTPORT=%d|MPICH_COMNIC=%s"),
&pszExtra[2], i, g_nHosts, pszHost, rootPort, pszHost);
}
SetEnvironmentVariables(pszEnv);
pEnv = GetEnvironmentStrings();
if (CreateProcess(
NULL,
pszCmdLine,
NULL, NULL, FALSE,
IDLE_PRIORITY_CLASS,
pEnv,
NULL,
&saInfo, &psInfo))
{
hProcess[i] = psInfo.hProcess;
CloseHandle(psInfo.hThread);
}
else
{
int error = GetLastError();
Translate_Error(error, error_msg, TEXT("CreateProcess failed: "));
_tprintf(TEXT("Unable to launch '%s', error %d: %s"), pszCmdLine, error, error_msg);
return;
}
RemoveEnvironmentVariables(pszEnv);
FreeEnvironmentStrings(pEnv);
}
// Wait for all the processes to terminate
WaitForLotsOfObjects(g_nHosts, hProcess);
for (i=0; i<g_nHosts; i++)
CloseHandle(hProcess[i]);
delete hProcess;
}
static VOID WINAPI DosStart(LPWORD Stack)
{
#ifdef STANDALONE
DWORD Result;
CHAR ApplicationName[MAX_PATH];
CHAR CommandLine[DOS_CMDLINE_LENGTH];
#endif
DPRINT1("DosStart\n");
/*
* We succeeded, deregister the DOS Starting BOP
* so that no app will be able to call us back.
*/
RegisterBop(BOP_START_DOS, NULL);
/* Load the mouse driver */
DosMouseInitialize();
#ifndef STANDALONE
/* Create the GetNextVDMCommand thread */
CommandThread = CreateThread(NULL, 0, &CommandThreadProc, NULL, 0, NULL);
if (CommandThread == NULL)
{
wprintf(L"FATAL: Failed to create the command processing thread: %d\n", GetLastError());
goto Quit;
}
/* Wait for the command thread to exit */
WaitForSingleObject(CommandThread, INFINITE);
/* Close the thread handle */
CloseHandle(CommandThread);
#else
if (NtVdmArgc >= 2)
{
WideCharToMultiByte(CP_ACP, 0, NtVdmArgv[1], -1, ApplicationName, sizeof(ApplicationName), NULL, NULL);
if (NtVdmArgc >= 3)
WideCharToMultiByte(CP_ACP, 0, NtVdmArgv[2], -1, CommandLine, sizeof(CommandLine), NULL, NULL);
else
strcpy(CommandLine, "");
}
else
{
DisplayMessage(L"Invalid DOS command line\n");
goto Quit;
}
/* Start the process from the command line */
DPRINT1("Starting '%s' ('%s')...\n", ApplicationName, CommandLine);
Result = DosStartProcess(ApplicationName,
CommandLine,
GetEnvironmentStrings());
if (Result != ERROR_SUCCESS)
{
DisplayMessage(L"Could not start '%S'. Error: %u", ApplicationName, Result);
goto Quit;
}
#endif
Quit:
/* Stop the VDM */
EmulatorTerminate();
}
BOOL _CreateProcessExA(HANDLE hToken, DWORD dwLogonFlags,
LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment,
LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation)
{
pid_t pid;
int flags;
int numArgs;
LPSTR* pArgs = NULL;
char** envp = NULL;
char* filename = NULL;
HANDLE thread;
HANDLE process;
WINPR_ACCESS_TOKEN* token;
LPTCH lpszEnvironmentBlock;
BOOL ret = FALSE;
pid = 0;
numArgs = 0;
lpszEnvironmentBlock = NULL;
pArgs = CommandLineToArgvA(lpCommandLine, &numArgs);
flags = 0;
token = (WINPR_ACCESS_TOKEN*) hToken;
if (lpEnvironment)
{
envp = EnvironmentBlockToEnvpA(lpEnvironment);
}
else
{
lpszEnvironmentBlock = GetEnvironmentStrings();
envp = EnvironmentBlockToEnvpA(lpszEnvironmentBlock);
}
filename = FindApplicationPath(pArgs[0]);
if (NULL == filename)
goto finish;
/* fork and exec */
pid = fork();
if (pid < 0)
{
/* fork failure */
goto finish;
}
if (pid == 0)
{
/* child process */
#ifdef __sun
closefrom(3);
#else
int maxfd;
#ifdef F_MAXFD // on some BSD derivates
maxfd = fcntl(0, F_MAXFD);
#else
maxfd = sysconf(_SC_OPEN_MAX);
#endif
int fd;
for(fd=3; fd<maxfd; fd++)
close(fd);
#endif // __sun
if (token)
{
if (token->GroupId)
{
int rc = setgid((gid_t) token->GroupId);
if (rc < 0)
{
}
else
{
initgroups(token->Username, (gid_t) token->GroupId);
}
}
if (token->UserId)
setuid((uid_t) token->UserId);
/* TODO: add better cwd handling and error checking */
if (lpCurrentDirectory && strlen(lpCurrentDirectory) > 0)
chdir(lpCurrentDirectory);
}
if (execve(filename, pArgs, envp) < 0)
{
/* execve failed - end the process */
_exit(1);
}
}
else
{
/* parent process */
}
process = CreateProcessHandle(pid);
if (!process)
{
goto finish;
}
thread = CreateNoneHandle();
if (!thread)
{
ProcessHandleCloseHandle(process);
goto finish;
}
lpProcessInformation->hProcess = process;
lpProcessInformation->hThread = thread;
lpProcessInformation->dwProcessId = (DWORD) pid;
lpProcessInformation->dwThreadId = (DWORD) pid;
ret = TRUE;
finish:
if (filename)
{
free(filename);
}
if (pArgs)
{
HeapFree(GetProcessHeap(), 0, pArgs);
}
if (lpszEnvironmentBlock)
FreeEnvironmentStrings(lpszEnvironmentBlock);
if (envp)
{
int i = 0;
while (envp[i])
{
free(envp[i]);
i++;
}
free(envp);
}
return ret;
}
void mhmakefileparser::SetExport(const string &Var, const string &Val)
{
m_Exports.insert(Var);
#ifdef WIN32
if (!m_pEnv)
{
/* Environment not created yet, so create one */
char *pEnv=GetEnvironmentStrings();
char *pEnd=pEnv;
while (*pEnd)
{
while (*pEnd++);
}
size_t Len=pEnd-pEnv+1;
m_pEnv=(char*)malloc(Len);
memcpy(m_pEnv,pEnv,Len);
m_EnvLen=Len;
FreeEnvironmentStrings(pEnv);
}
/* First check if the variable is in the environment, if so remove it first */
char *pEnv=m_pEnv;
while (*pEnv)
{
const char *pVar=Var.c_str();
char *pStart=pEnv;
while (*pEnv!='=' && tolower(*pEnv)==tolower(*pVar))
{
pEnv++; pVar++;
}
if (*pEnv=='=' && !*pVar)
{
/* Variable found, remove it */
while (*pEnv++);
m_EnvLen-=pEnv-pStart;
while (*pEnv)
{
while (*pEnv)
{
*pStart=*pEnv++;
pStart++;
}
*pStart=*pEnv++;
pStart++;
}
*pStart=*pEnv;
break;
}
while (*pEnv++);
}
size_t VarLen=Var.length();
size_t ValLen=Val.length();
size_t Extra=VarLen+ValLen+2;
/* Add the variable at the end */
m_pEnv=(char*)realloc(m_pEnv,m_EnvLen+Extra);
pEnv=m_pEnv+m_EnvLen-1;
memcpy(pEnv,Var.c_str(),VarLen);
pEnv+=VarLen;
*pEnv++='=';
memcpy(pEnv,Val.c_str(),ValLen);
pEnv+=ValLen;
*pEnv++='\0';
*pEnv++='\0';
m_EnvLen+=Extra;
#else
if (!m_pEnv)
{
/* Environment not created yet, so create one */
char **pEnv=environ;
char **pEnd=pEnv;
int Len=1;
while (*pEnd)
{
Len++;
pEnd++;
}
m_EnvLen=Len;
m_pEnv=(char**)malloc(Len*sizeof(pEnv));
int i=0;
while (*pEnv)
{
m_pEnv[i]=strdup(*pEnv);
i++;
pEnv++;
}
m_pEnv[i]=NULL;
}
/* First check if the variable is in the environment, if so replace it */
char **pEnv=m_pEnv;
while (*pEnv)
{
const char *pVar=Var.c_str();
char *pStart=*pEnv;
char *pTmp=pStart;
while (*pTmp!='=' && *pTmp==*pVar)
{
pTmp++; pVar++;
}
if (*pTmp=='=' && !*pVar)
{
free(*pEnv);
*pEnv=strdup((Var+"="+Val).c_str());
break;
}
pEnv++;
}
if (!*pEnv)
{
// Add it at the end of the list
m_pEnv=(char**)realloc(m_pEnv,(m_EnvLen+1)*sizeof(*pEnv));
m_pEnv[m_EnvLen-1]=strdup((Var+"="+Val).c_str());
m_pEnv[m_EnvLen++]=NULL;
}
#endif
}
bool CWebServer::CallCGI(CWebClientSocket* pClient, CStringA& hdr, CStringA& body, CStringA& mime)
{
CString path = pClient->m_path, redir = path;
if(!ToLocalPath(path, redir)) return false;
CString ext = CPath(path).GetExtension().MakeLower();
CPath dir(path);
dir.RemoveFileSpec();
CString cgi;
if(!m_cgi.Lookup(ext, cgi) || !CPath(cgi).FileExists())
return false;
HANDLE hProcess = GetCurrentProcess();
HANDLE hChildStdinRd, hChildStdinWr, hChildStdinWrDup = NULL;
HANDLE hChildStdoutRd, hChildStdoutWr, hChildStdoutRdDup = NULL;
SECURITY_ATTRIBUTES saAttr;
ZeroMemory(&saAttr, sizeof(saAttr));
saAttr.nLength = sizeof(saAttr);
saAttr.bInheritHandle = TRUE;
if(CreatePipe(&hChildStdoutRd, &hChildStdoutWr, &saAttr, 0))
{
BOOL fSuccess = DuplicateHandle(hProcess, hChildStdoutRd, hProcess, &hChildStdoutRdDup, 0, FALSE, DUPLICATE_SAME_ACCESS);
CloseHandle(hChildStdoutRd);
}
if(CreatePipe(&hChildStdinRd, &hChildStdinWr, &saAttr, 0))
{
BOOL fSuccess = DuplicateHandle(hProcess, hChildStdinWr, hProcess, &hChildStdinWrDup, 0, FALSE, DUPLICATE_SAME_ACCESS);
CloseHandle(hChildStdinWr);
}
STARTUPINFO siStartInfo;
ZeroMemory(&siStartInfo, sizeof(siStartInfo));
siStartInfo.cb = sizeof(siStartInfo);
siStartInfo.hStdError = hChildStdoutWr;
siStartInfo.hStdOutput = hChildStdoutWr;
siStartInfo.hStdInput = hChildStdinRd;
siStartInfo.dwFlags |= STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;
siStartInfo.wShowWindow = SW_HIDE;
PROCESS_INFORMATION piProcInfo;
ZeroMemory(&piProcInfo, sizeof(piProcInfo));
CStringA envstr;
if(LPVOID lpvEnv = GetEnvironmentStrings())
{
CString str;
CAtlList<CString> env;
for(LPTSTR lpszVariable = (LPTSTR)lpvEnv; *lpszVariable; lpszVariable += _tcslen(lpszVariable)+1)
if(lpszVariable != (LPTSTR)lpvEnv)
env.AddTail(lpszVariable);
env.AddTail(_T("GATEWAY_INTERFACE=CGI/1.1"));
env.AddTail(_T("SERVER_SOFTWARE=Media Player Classic/6.4.x.y"));
env.AddTail(_T("SERVER_PROTOCOL=") + pClient->m_ver);
env.AddTail(_T("REQUEST_METHOD=") + pClient->m_cmd);
env.AddTail(_T("PATH_INFO=") + redir);
env.AddTail(_T("PATH_TRANSLATED=") + path);
env.AddTail(_T("SCRIPT_NAME=") + redir);
env.AddTail(_T("QUERY_STRING=") + pClient->m_query);
if(pClient->m_hdrlines.Lookup(_T("content-type"), str))
env.AddTail(_T("CONTENT_TYPE=") + str);
if(pClient->m_hdrlines.Lookup(_T("content-length"), str))
env.AddTail(_T("CONTENT_LENGTH=") + str);
POSITION pos = pClient->m_hdrlines.GetStartPosition();
while(pos)
{
CString key = pClient->m_hdrlines.GetKeyAt(pos);
CString value = pClient->m_hdrlines.GetNextValue(pos);
key.Replace(_T("-"), _T("_"));
key.MakeUpper();
env.AddTail(_T("HTTP_") + key + _T("=") + value);
}
CString name;
UINT port;
if(pClient->GetPeerName(name, port))
{
str.Format(_T("%d"), port);
env.AddTail(_T("REMOTE_ADDR=")+name);
env.AddTail(_T("REMOTE_HOST=")+name);
env.AddTail(_T("REMOTE_PORT=")+str);
}
if(pClient->GetSockName(name, port))
{
str.Format(_T("%d"), port);
env.AddTail(_T("SERVER_NAME=")+name);
env.AddTail(_T("SERVER_PORT=")+str);
}
env.AddTail(_T("\0"));
str = Implode(env, '\0');
envstr = CStringA(str, str.GetLength());
FreeEnvironmentStrings((LPTSTR)lpvEnv);
}
TCHAR* cmdln = new TCHAR[32768];
_sntprintf(cmdln, 32768, _T("\"%s\" \"%s\""), cgi, path);
if(hChildStdinRd && hChildStdoutWr)
if(CreateProcess(
NULL, cmdln, NULL, NULL, TRUE, 0,
envstr.GetLength() ? (LPVOID)(LPCSTR)envstr : NULL,
dir, &siStartInfo, &piProcInfo))
{
DWORD ThreadId;
CreateThread(NULL, 0, KillCGI, (LPVOID)piProcInfo.hProcess, 0, &ThreadId);
static const int BUFFSIZE = 1024;
DWORD dwRead, dwWritten = 0;
int i = 0, len = pClient->m_data.GetLength();
for(; i < len; i += dwWritten)
if(!WriteFile(hChildStdinWrDup, (LPCSTR)pClient->m_data + i, min(len - i, BUFFSIZE), &dwWritten, NULL))
break;
CloseHandle(hChildStdinWrDup);
CloseHandle(hChildStdoutWr);
body.Empty();
CStringA buff;
while(i == len && ReadFile(hChildStdoutRdDup, buff.GetBuffer(BUFFSIZE), BUFFSIZE, &dwRead, NULL) && dwRead)
{
buff.ReleaseBufferSetLength(dwRead);
body += buff;
}
int hdrend = body.Find("\r\n\r\n");
if(hdrend >= 0)
{
hdr = body.Left(hdrend+2);
body = body.Mid(hdrend+4);
}
CloseHandle(hChildStdinRd);
CloseHandle(hChildStdoutRdDup);
CloseHandle(piProcInfo.hProcess);
CloseHandle(piProcInfo.hThread);
}
else
{
body = _T("CGI Error");
}
delete [] cmdln;
return true;
}
HRESULT CModuleConfiguration::CreateNodeEnvironment(IHttpContext* ctx, PCH namedPipe, PCH* env)
{
HRESULT hr;
LPCH currentEnvironment = NULL;
LPCH tmpStart, tmpIndex = NULL;
DWORD tmpSize;
DWORD environmentSize;
IAppHostElement* section = NULL;
IAppHostElementCollection* appSettings = NULL;
IAppHostElement* entry = NULL;
IAppHostPropertyCollection* properties = NULL;
IAppHostProperty* prop = NULL;
BSTR keyPropertyName = NULL;
BSTR valuePropertyName = NULL;
VARIANT vKeyPropertyName;
VARIANT vValuePropertyName;
DWORD count;
BSTR propertyValue;
int propertySize;
CheckNull(env);
*env = NULL;
// this is a zero terminated list of zero terminated strings of the form <var>=<value>
// calculate size of current environment
ErrorIf(NULL == (currentEnvironment = GetEnvironmentStrings()), GetLastError());
environmentSize = 0;
do {
while (*(currentEnvironment + environmentSize++) != 0);
} while (*(currentEnvironment + environmentSize++) != 0);
// allocate memory for new environment variables
tmpSize = 32767 - environmentSize;
ErrorIf(NULL == (tmpIndex = tmpStart = new char[tmpSize]), ERROR_NOT_ENOUGH_MEMORY);
RtlZeroMemory(tmpIndex, tmpSize);
// set PORT and IISNODE_VERSION variables
ErrorIf(tmpSize < (strlen(namedPipe) + strlen(IISNODE_VERSION) + 6 + 17), ERROR_NOT_ENOUGH_MEMORY);
sprintf(tmpIndex, "PORT=%s", namedPipe);
tmpIndex += strlen(namedPipe) + 6;
sprintf(tmpIndex, "IISNODE_VERSION=%s", IISNODE_VERSION);
tmpIndex += strlen(IISNODE_VERSION) + 17;
// add environment variables from the appSettings section of config
ErrorIf(NULL == (keyPropertyName = SysAllocString(L"key")), ERROR_NOT_ENOUGH_MEMORY);
vKeyPropertyName.vt = VT_BSTR;
vKeyPropertyName.bstrVal = keyPropertyName;
ErrorIf(NULL == (valuePropertyName = SysAllocString(L"value")), ERROR_NOT_ENOUGH_MEMORY);
vValuePropertyName.vt = VT_BSTR;
vValuePropertyName.bstrVal = valuePropertyName;
CheckError(GetConfigSection(ctx, §ion, L"appSettings"));
CheckError(section->get_Collection(&appSettings));
CheckError(appSettings->get_Count(&count));
for (USHORT i = 0; i < count; i++)
{
VARIANT index;
index.vt = VT_I2;
index.iVal = i;
CheckError(appSettings->get_Item(index, &entry));
CheckError(entry->get_Properties(&properties));
CheckError(properties->get_Item(vKeyPropertyName, &prop));
CheckError(prop->get_StringValue(&propertyValue));
ErrorIf(0 == (propertySize = WideCharToMultiByte(CP_ACP, 0, propertyValue, wcslen(propertyValue), NULL, 0, NULL, NULL)), E_FAIL);
ErrorIf((propertySize + 2) > (tmpSize - (tmpStart - tmpIndex)), ERROR_NOT_ENOUGH_MEMORY);
ErrorIf(propertySize != WideCharToMultiByte(CP_ACP, 0, propertyValue, wcslen(propertyValue), tmpIndex, propertySize, NULL, NULL), E_FAIL);
tmpIndex[propertySize] = '=';
tmpIndex += propertySize + 1;
SysFreeString(propertyValue);
propertyValue = NULL;
prop->Release();
prop = NULL;
CheckError(properties->get_Item(vValuePropertyName, &prop));
CheckError(prop->get_StringValue(&propertyValue));
ErrorIf(0 == (propertySize = WideCharToMultiByte(CP_ACP, 0, propertyValue, wcslen(propertyValue), NULL, 0, NULL, NULL)), E_FAIL);
ErrorIf((propertySize + 1) > (tmpSize - (tmpStart - tmpIndex)), ERROR_NOT_ENOUGH_MEMORY);
ErrorIf(propertySize != WideCharToMultiByte(CP_ACP, 0, propertyValue, wcslen(propertyValue), tmpIndex, propertySize, NULL, NULL), E_FAIL);
tmpIndex += propertySize + 1;
SysFreeString(propertyValue);
propertyValue = NULL;
prop->Release();
prop = NULL;
properties->Release();
properties = NULL;
entry->Release();
entry = NULL;
}
// concatenate new environment variables with the current environment block
ErrorIf(NULL == (*env = (LPCH)new char[environmentSize + (tmpIndex - tmpStart)]), ERROR_NOT_ENOUGH_MEMORY);
memcpy(*env, tmpStart, (tmpIndex - tmpStart));
memcpy(*env + (tmpIndex - tmpStart), currentEnvironment, environmentSize);
// cleanup
FreeEnvironmentStrings(currentEnvironment);
section->Release();
appSettings->Release();
SysFreeString(keyPropertyName);
SysFreeString(valuePropertyName);
delete [] tmpStart;
return S_OK;
Error:
if (currentEnvironment)
{
FreeEnvironmentStrings(currentEnvironment);
currentEnvironment = NULL;
}
if (section)
{
section->Release();
section = NULL;
}
if (appSettings)
{
appSettings->Release();
appSettings = NULL;
}
if (keyPropertyName)
{
SysFreeString(keyPropertyName);
keyPropertyName = NULL;
}
if (valuePropertyName)
{
SysFreeString(valuePropertyName);
valuePropertyName = NULL;
}
if (entry)
{
entry->Release();
entry = NULL;
}
if (properties)
{
properties->Release();
properties = NULL;
}
if (prop)
{
prop->Release();
prop = NULL;
}
if (propertyValue)
{
SysFreeString(propertyValue);
propertyValue = NULL;
}
if (tmpStart)
{
delete [] tmpStart;
tmpStart = NULL;
}
return hr;
}
void cdecl _EXPFUNC _tstartup(MODULE_DATA *mod_table)
{
EXCEPTIONREGISTRATIONRECORD hand;
MULTI_INIT *share_dll_table; /* module tables for DLLs */
int i;
/* Set the _isWindows flag if this is a Windows application.
* This is used by _ErrorMessage to determine whether to put
* up a dialog box or write to the console.
*/
_isWindows = mod_table->flags & MF_WINDOWS;
/* Disable precision, denormal, and underflow floating point exceptions,
* enable all others. Also set other control bits; see deflt87.c.
*/
_fpreset();
/* Initialize pointers to _matherr and _matherrl, _fmode, and _fileinfo
*/
_initmatherr(mod_table->matherr, mod_table->matherrl);
_initfmode(mod_table->fmode);
_initfileinfo(mod_table->pfileinfo);
/* Make up a MULTI_INIT structure for this EXE.
*/
_exe_table.ntables = 1;
_exe_table.table[0] = mod_table;
/* Save a pointer to the exception registration record in the stack.
* If signal() is used, or stack checking is enabled, or threads
* are created, except.c will be linked in and will use this pointer
* to install an exception handler.
*/
_ExcRegPtr = &hand;
/* Hack to link in GP handler */
_InitDefaultHander();
/* Set up global variables pointing to the environment data
* and command line, respectively. These are used by _INIT_
* functions to set up argc, argv, and _environ before main is called.
* Also save the module handle for use by WINMAIN.
*/
_tosenv = GetEnvironmentStrings();
_toscmd = GetCommandLine();
/* Initialize wildcard expansion if necessary
*/
_init_wild_handlers(mod_table->wild_func, mod_table->wwild_func);
/* Initialize pointers to the routines that will handle the argv
processing.
*/
_init_setargv_handlers(
mod_table->setargv_func,
mod_table->exitargv_func,
mod_table->wsetargv_func,
mod_table->wexitargv_func
);
/* Call initialization functions for any DLLs that might have
* been loaded. Then call each DLL's pseudo-entry point,
* which simply calls that DLL's _dllmain().
*/
if ((share_dll_table = _create_shmem()) != NULL)
{
/* Put a -1 marker at the end of the list of DLL module tables.
* This forces any DLLs that are loaded dynamically later to
* call their initialization functions themselves.
*/
share_dll_table->table[share_dll_table->ntables] = (MODULE_DATA *)-1;
/* Call all the _INIT_ functions
*/
_init_exit_proc(share_dll_table, 0);
/* Call _dllmain.
*/
for (i = 0; i < share_dll_table->ntables; i++)
#pragma warn -pro
share_dll_table->table[i]->main(0, share_dll_table->table[i]->hmod);
#pragma warn .pro
}
/* Call all the initialization functions for the EXE.
*/
_init_exit_proc(&_exe_table, 0);
if (mod_table->flags & MF_WINDOWS)
{
_TCHAR *cmdline, termchar;
/* Skip past leading whitespace in command line.
*/
for (cmdline = _toscmd; *cmdline == _TEXT(' ') || *cmdline == _TEXT('\t'); cmdline++)
;
/* Check whether EXE name is quoted, if so then we need to search for
* the terminating quote.
*/
if (*cmdline == _TEXT('"'))
{
termchar = _TEXT('"');
cmdline++;
}
else
termchar = _TEXT(' ');
/* Skip past program name.
*/
while (*cmdline && *cmdline != termchar && *cmdline != _TEXT('\t'))
cmdline++;
/* If we ended up on terminating quote then skip it.
*/
if (*cmdline == _TEXT('"'))
cmdline++;
/* Skip past leading whitespace in command line.
*/
while (*cmdline && *cmdline == _TEXT(' ') || *cmdline == _TEXT('\t'))
cmdline++;
/* Call WinMain, exit with its return code.
*/
#pragma warn -pro
exit(mod_table->main(GetModuleHandle(NULL), NULL, cmdline, GetSWFlag()));
#pragma warn .pro
}
else
{
/* Call main, exit with its return code.
*/
#pragma warn -pro
exit(mod_table->main(_C0argc,_tC0argv,_tC0environ));
#pragma warn .pro
}
}
