static bool yaf_route_rewrite_route(const Object& o, const Object& request)
{
char req_uri[8192];
auto ptr_req_uri = request->o_realProp(YAF_REQUEST_PROPERTY_NAME_URI,
ObjectData::RealPropUnchecked, "Yaf_Request_Abstract");
auto ptr_req_baseuri = request->o_realProp(YAF_REQUEST_PROPERTY_NAME_BASE,
ObjectData::RealPropUnchecked, "Yaf_Request_Abstract");
if (ptr_req_uri == NULL) {
raise_warning("invalid ptr_uri:%p", ptr_req_uri);
return false;
}
if (ptr_req_baseuri->isString()
&& !strncasecmp(ptr_req_uri->toString().c_str(),
ptr_req_baseuri->toString().c_str(), ptr_req_baseuri->toString().length())) {
const char* tmp_req_uri = ptr_req_uri->toString().c_str() + ptr_req_baseuri->toString().length();
snprintf(req_uri, sizeof(req_uri), "%s", tmp_req_uri);
} else {
const char* tmp_req_uri = ptr_req_uri->toString().c_str();
snprintf(req_uri, sizeof(req_uri), "%s", tmp_req_uri);
}
Variant ret = yaf_route_rewrite_match(o, req_uri, strlen(req_uri));
if (ret.isNull()) {
return false;
}
auto ptr_route = o->o_realProp(YAF_ROUTE_PROPETY_NAME_ROUTE,
ObjectData::RealPropUnchecked, "Yaf_Route_Rewrite");
Array& route = ptr_route->toArrRef();
if (route.exists(String("module"))) {
auto ptr_module = request->o_realProp(YAF_REQUEST_PROPERTY_NAME_MODULE,
ObjectData::RealPropUnchecked, "Yaf_Request_Abstract");
*ptr_module = route[String("module")];
}
if (route.exists(String("controller"))) {
auto ptr_controller = request->o_realProp(YAF_REQUEST_PROPERTY_NAME_CONTROLLER,
ObjectData::RealPropUnchecked, "Yaf_Request_Abstract");
*ptr_controller = route[String("controller")];
}
if (route.exists(String("action"))) {
auto ptr_action = request->o_realProp(YAF_REQUEST_PROPERTY_NAME_ACTION,
ObjectData::RealPropUnchecked, "Yaf_Request_Abstract");
*ptr_action = route[String("action")];
}
(void)yaf_request_set_params_multi(&request, ret.toArray());
return true;
}
static Variant HHVM_METHOD(Yaf_Request_Http, get, const Variant& name,
const Variant& def)
{
if (name.isNull()) {
return def;
}
auto paramsTmp = this_->o_realProp(YAF_REQUEST_PROPERTY_NAME_PARAMS,
ObjectData::RealPropUnchecked, "Yaf_Request_Http");
if (paramsTmp->isNull()) {
return def;
}
Array& params = paramsTmp->toArrRef();
if (params.exists(name)) {
return params[name];
}
if (php_global(S_POST).toArray().exists(name)) {
return php_global(S_POST).toArray()[name];
}
if (php_global(S_GET).toArray().exists(name)) {
return php_global(S_GET).toArray()[name];
}
if (php_global(S_COOKIE).toArray().exists(name)) {
return php_global(S_COOKIE).toArray()[name];
}
if (php_global(S_SERVER).toArray().exists(name)) {
return php_global(S_SERVER).toArray()[name];
}
return def;
}
void DummySandbox::run() {
TRACE(2, "DummySandbox::run\n");
RequestInfo *ti = RequestInfo::s_requestInfo.getNoCheck();
while (!m_stopped) {
try {
CLISession hphpSession;
DSandboxInfo sandbox = m_proxy->getSandbox();
std::string msg;
if (sandbox.valid()) {
SourceRootInfo sri(sandbox.m_user, sandbox.m_name);
if (sandbox.m_path.empty()) {
sandbox.m_path = sri.path();
}
if (!sri.sandboxOn()) {
msg = "Invalid sandbox was specified. "
"PHP files may not be loaded properly.\n";
} else {
auto server = php_global_exchange(s__SERVER, init_null());
forceToArray(server);
Array arr = server.toArrRef();
server.unset();
php_global_set(s__SERVER, sri.setServerVariables(std::move(arr)));
}
Debugger::RegisterSandbox(sandbox);
g_context->setSandboxId(sandbox.id());
std::string doc = getStartupDoc(sandbox);
if (!doc.empty()) {
char cwd[PATH_MAX];
getcwd(cwd, sizeof(cwd));
Logger::Info("Start loading startup doc '%s', pwd = '%s'",
doc.c_str(), cwd);
bool error; std::string errorMsg;
bool ret = hphp_invoke(g_context.getNoCheck(), doc, false, null_array,
uninit_null(), "", "", error, errorMsg, true,
false, true, RuntimeOption::EvalPreludePath);
if (!ret || error) {
msg += "Unable to pre-load " + doc;
if (!errorMsg.empty()) {
msg += ": " + errorMsg;
}
}
Logger::Info("Startup doc " + doc + " loaded");
}
} else {
g_context->setSandboxId(m_proxy->getDummyInfo().id());
}
if (!DebuggerHook::attach<HphpdHook>(ti)) {
const char* fail = "Could not attach hphpd to request: another debugger"
" is already attached.";
Logger::Error("%s", fail);
Debugger::InterruptSessionStarted(nullptr, fail);
throw DebuggerClientAttachFailureException();
}
{
DebuggerDummyEnv dde;
// This is really the entire point of having the dummy sandbox. This
// fires the initial session started interrupt to the client after
// it first attaches.
Debugger::InterruptSessionStarted(nullptr, msg.c_str());
}
// Blocking until Ctrl-C is issued by end user and DebuggerProxy cannot
// find a real sandbox thread to handle it.
{
Lock lock(this);
while (!m_stopped && m_signum != CmdSignal::SignalBreak) {
wait(1);
}
if (m_stopped) {
// stopped by worker thread
break;
}
m_signum = CmdSignal::SignalNone;
}
} catch (const DebuggerClientExitException& e) {
// stopped by the dummy sandbox thread itself
break;
} catch (const DebuggerException& e) {
}
}
}
void _xml_characterDataHandler(void *userData, const XML_Char *s, int len) {
auto parser = getParserFromToken(userData);
if (parser) {
Variant retval;
Array args = Array::Create();
if (parser->characterDataHandler.toBoolean()) {
args.append(Variant(parser));
args.append(_xml_xmlchar_zval(s, len, parser->target_encoding));
xml_call_handler(parser, parser->characterDataHandler, args);
}
if (!parser->data.isNull()) {
int i;
int doprint = 0;
String decoded_value;
int decoded_len;
decoded_value = xml_utf8_decode(s,len,
parser->target_encoding);
decoded_len = decoded_value.size();
for (i = 0; i < decoded_len; i++) {
switch (decoded_value[i]) {
case ' ':
case '\t':
case '\n':
default:
doprint = 1;
break;
}
if (doprint) {
break;
}
}
if (doprint || (! parser->skipwhite)) {
if (parser->lastwasopen) {
String myval;
// check if value exists, if yes append to that
if (parser->ctag.toArrRef().exists(s_value)) {
myval = tvCastToString(parser->ctag.toArray().rvalAt(s_value).tv());
myval += decoded_value;
parser->ctag.toArrRef().set(s_value, myval);
} else {
parser->ctag.toArrRef().set(
s_value,
decoded_value
);
}
} else {
Array tag;
String myval;
String mytype;
auto curtag = parser->data.toArrRef().pop();
SCOPE_EXIT {
try {
parser->data.toArrRef().append(curtag);
} catch (...) {}
};
if (curtag.toArrRef().exists(s_type)) {
mytype = tvCastToString(curtag.toArrRef().rvalAt(s_type).tv());
if (!strcmp(mytype.data(), "cdata") &&
curtag.toArrRef().exists(s_value)) {
myval = tvCastToString(curtag.toArrRef().rvalAt(s_value).tv());
myval += decoded_value;
curtag.toArrRef().set(s_value, myval);
return;
}
}
if (parser->level <= XML_MAXLEVEL && parser->level > 0) {
tag = Array::Create();
_xml_add_to_info(parser, parser->ltags[parser->level-1] +
parser->toffset);
tag.set(s_tag, String(parser->ltags[parser->level-1] +
parser->toffset, CopyString));
tag.set(s_value, decoded_value);
tag.set(s_type, s_cdata);
tag.set(s_level, parser->level);
parser->data.toArrRef().append(tag);
} else if (parser->level == (XML_MAXLEVEL + 1)) {
raise_warning("Maximum depth exceeded - Results truncated");
}
}
}
}
}
