bool RPCRequestHandler::executePHPFunction(Transport *transport,
SourceRootInfo &sourceRootInfo) {
// reset timeout counter
ThreadInfo::s_threadInfo->m_reqInjectionData.started = time(0);
std::string rpcFunc = transport->getCommand();
{
ServerStatsHelper ssh("input");
RequestURI reqURI(rpcFunc);
HttpProtocol::PrepareSystemVariables(transport, reqURI, sourceRootInfo);
sourceRootInfo.clear();
}
bool error = false;
Array params;
std::string sparams = transport->getParam("params");
if (!sparams.empty()) {
Variant jparams = f_json_decode(String(sparams), true);
if (jparams.isArray()) {
params = jparams.toArray();
} else {
error = true;
}
} else {
vector<string> sparams;
transport->getArrayParam("p", sparams);
if (!sparams.empty()) {
for (unsigned int i = 0; i < sparams.size(); i++) {
Variant jparams = f_json_decode(String(sparams[i]), true);
if (same(jparams, false)) {
error = true;
break;
}
params.append(jparams);
}
} else {
// single string parameter, used by xbox to avoid any en/decoding
int size;
const void *data = transport->getPostData(size);
if (data && size) {
params.append(String((char*)data, size, AttachLiteral));
}
}
}
if (transport->getIntParam("reset") == 1) {
m_reset = true;
}
int output = transport->getIntParam("output");
int code;
if (!error) {
Variant funcRet;
std::string errorMsg = "Internal Server Error";
string warmupDoc, reqInitFunc, reqInitDoc;
if (m_serverInfo) {
warmupDoc = m_serverInfo->getWarmupDoc();
reqInitFunc = m_serverInfo->getReqInitFunc();
reqInitDoc = m_serverInfo->getReqInitDoc();
}
if (!warmupDoc.empty()) warmupDoc = canonicalize_path(warmupDoc, "", 0);
if (!warmupDoc.empty()) warmupDoc = get_source_filename(warmupDoc.c_str());
bool ret = hphp_invoke(m_context, rpcFunc, true, params, ref(funcRet),
warmupDoc, reqInitFunc, reqInitDoc,
error, errorMsg);
if (ret) {
String response;
switch (output) {
case 0: response = f_json_encode(funcRet); break;
case 1: response = m_context->obDetachContents(); break;
case 2:
response =
f_json_encode(CREATE_MAP2("output", m_context->obDetachContents(),
"return", f_json_encode(funcRet)));
break;
}
code = 200;
transport->sendRaw((void*)response.data(), response.size());
} else if (error) {
code = 500;
transport->sendString(errorMsg, 500);
m_reset = true;
} else {
code = 404;
transport->sendString("Not Found", 404);
}
} else {
code = 400;
transport->sendString("Bad Request", 400);
}
params.reset();
transport->onSendEnd();
ServerStats::LogPage(rpcFunc, code);
m_context->onShutdownPostSend();
m_context->restoreSession();
return !error;
}
bool RPCRequestHandler::executePHPFunction(Transport *transport,
SourceRootInfo &sourceRootInfo,
ReturnEncodeType returnEncodeType) {
std::string rpcFunc = transport->getCommand();
{
ServerStatsHelper ssh("input");
RequestURI reqURI(rpcFunc);
HttpProtocol::PrepareSystemVariables(transport, reqURI, sourceRootInfo);
auto env = php_global(s__ENV);
env.toArrRef().set(s_HPHP_RPC, 1);
php_global_set(s__ENV, std::move(env));
}
bool isFile = rpcFunc.rfind('.') != std::string::npos;
std::string rpcFile;
bool error = false;
Array params;
std::string sparams = transport->getParam("params");
if (!sparams.empty()) {
Variant jparams = HHVM_FN(json_decode)(String(sparams), true);
if (jparams.isArray()) {
params = jparams.toArray();
} else {
error = true;
}
} else {
std::vector<std::string> sparams;
transport->getArrayParam("p", sparams);
if (!sparams.empty()) {
for (unsigned int i = 0; i < sparams.size(); i++) {
Variant jparams = HHVM_FN(json_decode)(String(sparams[i]), true);
if (same(jparams, false)) {
error = true;
break;
}
params.append(jparams);
}
} else {
// single string parameter, used by xbox to avoid any en/decoding
int size;
const void *data = transport->getPostData(size);
if (data && size) {
params.append(String((char*)data, size, CopyString));
}
}
}
if (transport->getIntParam("reset") == 1) {
m_reset = true;
}
int output = transport->getIntParam("output");
int code;
if (!error) {
Variant funcRet;
std::string errorMsg = "Internal Server Error";
std::string reqInitFunc, reqInitDoc;
reqInitDoc = transport->getHeader("ReqInitDoc");
if (reqInitDoc.empty() && m_serverInfo) {
reqInitFunc = m_serverInfo->getReqInitFunc();
reqInitDoc = m_serverInfo->getReqInitDoc();
}
if (!reqInitDoc.empty()) {
reqInitDoc = (std::string)canonicalize_path(reqInitDoc, "", 0);
}
if (!reqInitDoc.empty()) {
reqInitDoc = getSourceFilename(reqInitDoc, sourceRootInfo);
}
bool runOnce = false;
bool ret = true;
if (isFile) {
rpcFile = rpcFunc;
rpcFunc.clear();
} else {
rpcFile = transport->getParam("include");
if (rpcFile.empty()) {
rpcFile = transport->getParam("include_once");
runOnce = true;
}
}
if (!rpcFile.empty()) {
// invoking a file through rpc
bool forbidden = false;
if (!RuntimeOption::ForbiddenFileExtensions.empty()) {
const char *ext = rpcFile.c_str() + rpcFile.rfind('.') + 1;
if (RuntimeOption::ForbiddenFileExtensions.find(ext) !=
RuntimeOption::ForbiddenFileExtensions.end()) {
forbidden = true;
}
}
if (!forbidden) {
rpcFile = (std::string) canonicalize_path(rpcFile, "", 0);
rpcFile = getSourceFilename(rpcFile, sourceRootInfo);
ret = hphp_invoke(m_context, rpcFile, false, Array(), uninit_null(),
reqInitFunc, reqInitDoc, error, errorMsg, runOnce);
}
// no need to do the initialization for a second time
reqInitFunc.clear();
reqInitDoc.clear();
}
if (ret && !rpcFunc.empty()) {
ret = hphp_invoke(m_context, rpcFunc, true, params, ref(funcRet),
reqInitFunc, reqInitDoc, error, errorMsg);
}
if (ret) {
bool serializeFailed = false;
String response;
switch (output) {
case 0: {
assert(returnEncodeType == ReturnEncodeType::Json ||
returnEncodeType == ReturnEncodeType::Serialize);
try {
response = (returnEncodeType == ReturnEncodeType::Json) ?
HHVM_FN(json_encode)(funcRet) :
f_serialize(funcRet);
} catch (...) {
serializeFailed = true;
}
break;
}
case 1: response = m_context->obDetachContents(); break;
case 2:
response =
HHVM_FN(json_encode)(
make_map_array(s_output, m_context->obDetachContents(),
s_return, HHVM_FN(json_encode)(funcRet)));
break;
case 3: response = f_serialize(funcRet); break;
}
if (serializeFailed) {
code = 500;
transport->sendString(
"Serialization of the return value failed", 500);
m_reset = true;
} else {
transport->sendRaw((void*)response.data(), response.size());
code = transport->getResponseCode();
}
} else if (error) {
code = 500;
transport->sendString(errorMsg, 500);
m_reset = true;
} else {
code = 404;
transport->sendString("Not Found", 404);
}
} else {
code = 400;
transport->sendString("Bad Request", 400);
}
params.reset();
sourceRootInfo.clear();
transport->onSendEnd();
ServerStats::LogPage(isFile ? rpcFile : rpcFunc, code);
m_context->onShutdownPostSend();
m_context->obClean(); // in case postsend/cleanup output something
m_context->restoreSession();
return !error;
}
bool RPCRequestHandler::executePHPFunction(Transport *transport,
SourceRootInfo &sourceRootInfo) {
// reset timeout counter
ThreadInfo::s_threadInfo->m_reqInjectionData.started = time(0);
string rpcFunc = transport->getCommand();
{
ServerStatsHelper ssh("input");
RequestURI reqURI(rpcFunc);
HttpProtocol::PrepareSystemVariables(transport, reqURI, sourceRootInfo);
}
bool isFile = rpcFunc.rfind('.') != string::npos;
string rpcFile;
bool error = false;
Array params;
string sparams = transport->getParam("params");
if (!sparams.empty()) {
Variant jparams = f_json_decode(String(sparams), true);
if (jparams.isArray()) {
params = jparams.toArray();
} else {
error = true;
}
} else {
vector<string> sparams;
transport->getArrayParam("p", sparams);
if (!sparams.empty()) {
for (unsigned int i = 0; i < sparams.size(); i++) {
Variant jparams = f_json_decode(String(sparams[i]), true);
if (same(jparams, false)) {
error = true;
break;
}
params.append(jparams);
}
} else {
// single string parameter, used by xbox to avoid any en/decoding
int size;
const void *data = transport->getPostData(size);
if (data && size) {
params.append(String((char*)data, size, AttachLiteral));
}
}
}
if (transport->getIntParam("reset") == 1) {
m_reset = true;
}
int output = transport->getIntParam("output");
int code;
if (!error) {
Variant funcRet;
string errorMsg = "Internal Server Error";
string warmupDoc, reqInitFunc, reqInitDoc;
if (m_serverInfo) {
warmupDoc = m_serverInfo->getWarmupDoc();
reqInitFunc = m_serverInfo->getReqInitFunc();
reqInitDoc = m_serverInfo->getReqInitDoc();
}
if (!warmupDoc.empty()) warmupDoc = canonicalize_path(warmupDoc, "", 0);
if (!warmupDoc.empty()) {
warmupDoc = getSourceFilename(warmupDoc, sourceRootInfo);
}
if (!reqInitDoc.empty()) reqInitDoc = canonicalize_path(reqInitDoc, "", 0);
if (!reqInitDoc.empty()) {
reqInitDoc = getSourceFilename(reqInitDoc, sourceRootInfo);
}
bool runOnce = false;
bool ret = true;
if (isFile) {
rpcFile = rpcFunc;
rpcFunc.clear();
} else {
rpcFile = transport->getParam("include");
if (rpcFile.empty()) {
rpcFile = transport->getParam("include_once");
runOnce = true;
}
}
if (!rpcFile.empty()) {
// invoking a file through rpc
bool forbidden = false;
if (!RuntimeOption::ForbiddenFileExtensions.empty()) {
const char *ext = rpcFile.c_str() + rpcFile.rfind('.') + 1;
if (RuntimeOption::ForbiddenFileExtensions.find(ext) !=
RuntimeOption::ForbiddenFileExtensions.end()) {
forbidden = true;
}
}
if (!forbidden) {
rpcFile = canonicalize_path(rpcFile, "", 0);
rpcFile = getSourceFilename(rpcFile, sourceRootInfo);
ret = hphp_invoke(m_context, rpcFile, false, Array(), null,
warmupDoc, reqInitFunc, reqInitDoc,
error, errorMsg, runOnce);
}
// no need to do the initialization for a second time
warmupDoc.clear();
reqInitFunc.clear();
reqInitDoc.clear();
}
if (ret && !rpcFunc.empty()) {
ret = hphp_invoke(m_context, rpcFunc, true, params, ref(funcRet),
warmupDoc, reqInitFunc, reqInitDoc,
error, errorMsg);
}
if (ret) {
String response;
switch (output) {
case 0: response = f_json_encode(funcRet); break;
case 1: response = m_context->obDetachContents(); break;
case 2:
response =
f_json_encode(CREATE_MAP2("output", m_context->obDetachContents(),
"return", f_json_encode(funcRet)));
break;
case 3: response = f_serialize(funcRet); break;
}
transport->sendRaw((void*)response.data(), response.size());
code = transport->getResponseCode();
} else if (error) {
code = 500;
transport->sendString(errorMsg, 500);
m_reset = true;
} else {
code = 404;
transport->sendString("Not Found", 404);
}
} else {
code = 400;
transport->sendString("Bad Request", 400);
}
params.reset();
sourceRootInfo.clear();
transport->onSendEnd();
ServerStats::LogPage(isFile ? rpcFile : rpcFunc, code);
m_context->onShutdownPostSend();
m_context->obClean(); // in case postsend/cleanup output something
m_context->restoreSession();
return !error;
}
void BNode::build(Array <BTri> &tris, const int splitCost, const int balCost, const float epsilon){
uint index = 0;
int minScore = 0x7FFFFFFF;
for (uint i = 0; i < tris.getCount(); i++){
int score = 0;
int diff = 0;
for (uint k = 0; k < tris.getCount(); k++){
uint neg = 0, pos = 0;
for (uint j = 0; j < 3; j++){
float dist = planeDistance(tris[i].plane, tris[k].v[j]);
if (dist < -epsilon) neg++; else
if (dist > epsilon) pos++;
}
if (pos){
if (neg) score += splitCost; else diff++;
} else {
if (neg) diff--; else diff++;
}
}
score += balCost * abs(diff);
if (score < minScore){
minScore = score;
index = i;
}
}
tri = tris[index];
tris.fastRemove(index);
Array <BTri> backTris;
Array <BTri> frontTris;
for (uint i = 0; i < tris.getCount(); i++){
uint neg = 0, pos = 0;
for (uint j = 0; j < 3; j++){
float dist = planeDistance(tri.plane, tris[i].v[j]);
if (dist < -epsilon) neg++; else
if (dist > epsilon) pos++;
}
if (neg){
if (pos){
BTri newTris[3];
int nPos, nNeg;
tris[i].split(newTris, nPos, nNeg, tri.plane, epsilon);
for (int i = 0; i < nPos; i++){
frontTris.add(newTris[i]);
}
for (int i = 0; i < nNeg; i++){
backTris.add(newTris[nPos + i]);
}
} else {
backTris.add(tris[i]);
}
} else {
frontTris.add(tris[i]);
}
}
tris.reset();
if (backTris.getCount() > 0){
back = new BNode;
back->build(backTris, splitCost, balCost, epsilon);
} else back = NULL;
if (frontTris.getCount() > 0){
front = new BNode;
front->build(frontTris, splitCost, balCost, epsilon);
} else front = NULL;
}
//бля, это пиздец
int ArchiveModuleManager::QueryArchives(
const TCHAR* lpFileName,
const unsigned char* pBuffer,
DWORD dwBufferSize,
Array<ArchiveFormat*>& result
)
{
bool bStopped = false;
//BADBAD
if ( !dwBufferSize )
{
result.reset();
return 0;
};
ArchiveFilter* pFilter = m_pConfig->GetFilter();
Array<ArchiveFilterEntry*> filters;
pFilter->Reset();
pFilter->QueryFilters(lpFileName, filters, bStopped);
for (unsigned int i = 0; i < filters.count(); i++)
{
ArchiveFilterEntry* pFE = filters[i];
ArchiveModule* pModule = pFE->GetModule();
bool bNoPluginsFiltered = true;
bool bNoFormatsFiltered = true;
if ( !pFilter->Filtered(&pModule->GetUID(), NULL, NULL) )
{
if ( pFE->IsAllPlugins() )
{
Array<ArchivePlugin*>& plugins = pModule->GetPlugins();
for (unsigned int i = 0; i < plugins.count(); i++)
{
ArchivePlugin* pPlugin = plugins[i];
if ( !pFilter->Filtered(&pModule->GetUID(), &pPlugin->GetUID(), NULL) )
{
if ( pModule->QueryCapability(AMF_SUPPORT_SINGLE_PLUGIN_QUERY) )
{
Array<ArchiveFormat*>& formats = pPlugin->GetFormats();
for (unsigned int j = 0; j < formats.count(); j++)
{
ArchiveFormat* pFormat = formats[i];
if ( !pFilter->Filtered(&pModule->GetUID(), &pPlugin->GetUID(), &pFormat->GetUID()) )
{
if ( pPlugin->QueryCapability(APF_SUPPORT_SINGLE_FORMAT_QUERY) )
pModule->QueryArchives(&pPlugin->GetUID(), &pFormat->GetUID(), lpFileName, pBuffer, dwBufferSize, result);
}
else
bNoFormatsFiltered = false;
}
if ( bNoFormatsFiltered && !pPlugin->QueryCapability(APF_SUPPORT_SINGLE_FORMAT_QUERY) )
pModule->QueryArchives(&pPlugin->GetUID(), NULL, lpFileName, pBuffer, dwBufferSize, result);
}
else
bNoPluginsFiltered = false;
}
if ( bNoPluginsFiltered && !pModule->QueryCapability(AMF_SUPPORT_SINGLE_PLUGIN_QUERY) )
pModule->QueryArchives(NULL, NULL, lpFileName, pBuffer, dwBufferSize, result);
}
}
else
{
if ( pFE->IsAllFormats() )
{
ArchivePlugin* pPlugin = pFE->GetPlugin();
if ( !pFilter->Filtered(&pModule->GetUID(), &pPlugin->GetUID(), NULL) )
{
Array<ArchiveFormat*>& formats = pPlugin->GetFormats();
for (unsigned int i = 0; i < formats.count(); i++)
{
ArchiveFormat* pFormat = formats[i];
if ( !pFilter->Filtered(&pModule->GetUID(), &pPlugin->GetUID(), &pFormat->GetUID()) )
{
if ( pPlugin->QueryCapability(APF_SUPPORT_SINGLE_FORMAT_QUERY) )
pModule->QueryArchives(&pPlugin->GetUID(), &pFormat->GetUID(), lpFileName, pBuffer, dwBufferSize, result);
}
else
bNoFormatsFiltered = false;
}
if ( bNoFormatsFiltered && !pPlugin->QueryCapability(APF_SUPPORT_SINGLE_FORMAT_QUERY) )
pModule->QueryArchives(&pPlugin->GetUID(), NULL, lpFileName, pBuffer, dwBufferSize, result);
}
}
else
{
ArchiveFormat* pFormat = pFE->GetFormat();
ArchivePlugin* pPlugin = pFE->GetPlugin();
if ( !pFilter->Filtered(&pModule->GetUID(), &pPlugin->GetUID(), &pFormat->GetUID()) )
{
if ( pPlugin->QueryCapability(APF_SUPPORT_SINGLE_FORMAT_QUERY) )
pModule->QueryArchives(&pPlugin->GetUID(), &pFormat->GetUID(), lpFileName, pBuffer, dwBufferSize, result);
}
}
}
}
pFilter->AddStopFilter(filters[i]);
}
if ( !bStopped && pFilter->UseRemaining() )
{
for (unsigned int i = 0; i < m_pModules.count(); i++)
{
bool bNoPluginsFiltered = true;
bool bNoFormatsFiltered = true;
ArchiveModule* pModule = m_pModules[i];
if ( !pFilter->Filtered(&pModule->GetUID(), NULL, NULL) )
{
Array<ArchivePlugin*>& plugins = pModule->GetPlugins();
for (unsigned int j = 0; j < plugins.count(); j++)
{
ArchivePlugin* pPlugin = plugins[j];
if ( !pFilter->Filtered(&pModule->GetUID(), &pPlugin->GetUID(), NULL) )
{
Array<ArchiveFormat*>& formats = pPlugin->GetFormats();
for (unsigned int k = 0; k < formats.count(); k++)
{
ArchiveFormat* pFormat = formats[k];
if ( !pFilter->Filtered(&pModule->GetUID(), &pPlugin->GetUID(), &pFormat->GetUID()) )
{
if ( pPlugin->QueryCapability(APF_SUPPORT_SINGLE_FORMAT_QUERY) )
pModule->QueryArchives(&pPlugin->GetUID(), &pFormat->GetUID(), lpFileName, pBuffer, dwBufferSize, result);
}
else
bNoFormatsFiltered = false;
}
if ( bNoFormatsFiltered && !pPlugin->QueryCapability(APF_SUPPORT_SINGLE_FORMAT_QUERY) )
pModule->QueryArchives(&pPlugin->GetUID(), NULL, lpFileName, pBuffer, dwBufferSize, result);
}
else
bNoPluginsFiltered = false;
}
if ( bNoPluginsFiltered && !pModule->QueryCapability(AMF_SUPPORT_SINGLE_PLUGIN_QUERY) )
pModule->QueryArchives(NULL, NULL, lpFileName, pBuffer, dwBufferSize, result);
}
}
}
return 0;
}
