SourceRootInfo::SourceRootInfo(Transport* transport)
: m_sandboxCond(RuntimeOption::SandboxMode ? SandboxCondition::On :
SandboxCondition::Off) {
s_path.destroy();
s_phproot.destroy();
auto documentRoot = transport->getDocumentRoot();
if (!documentRoot.empty()) {
m_user = s___builtin;
m_sandbox = s_default;
// The transport take precedence over the config file
m_path = documentRoot;
*s_path.getCheck() = documentRoot;
return;
}
if (!sandboxOn()) return;
auto host = transport->getHeader("Host");
Variant matches;
Variant r = preg_match(String(RuntimeOption::SandboxPattern.c_str(),
RuntimeOption::SandboxPattern.size(),
CopyString), host, &matches);
if (!same(r, 1)) {
m_sandboxCond = SandboxCondition::Off;
return;
}
if (RuntimeOption::SandboxFromCommonRoot) {
auto sandboxName = tvCastToString(matches.toArray().rvalAt(1).tv());
createFromCommonRoot(sandboxName);
} else {
Array pair = StringUtil::Explode(
tvCastToString(matches.toArray().rvalAt(1).tv()),
"-", 2
).toArray();
m_user = tvCastToString(pair.rvalAt(0).tv());
bool defaultSb = pair.size() == 1;
if (defaultSb) {
m_sandbox = s_default;
} else {
m_sandbox = tvCastToString(pair.rvalAt(1).tv());
}
createFromUserConfig();
}
*s_path.getCheck() = m_path.c_str();
}
ZEND_API void zend_make_printable_zval(zval *expr, zval *expr_copy, int *use_copy) {
if (Z_TYPE_P(expr)==IS_STRING) {
*use_copy = 0;
return;
}
HPHP::StringData *str = tvCastToString(expr->tv());
ZVAL_STRING(expr_copy, str->data(), str->size());
*use_copy = 1;
}
void find_var_recursive(const TypedValue* tv, WddxPacket* wddxPacket) {
if (tvIsString(tv)) {
String var_name = tvCastToString(tv);
wddxPacket->add_var(var_name, true);
}
if (tv->m_type == KindOfArray) {
for (ArrayIter iter(tv->m_data.parr); iter; ++iter) {
find_var_recursive(iter.secondRef().asTypedValue(), wddxPacket);
}
}
}
void find_var_recursive(const TypedValue* tv,
const req::ptr<WddxPacket>& wddxPacket) {
if (tvIsString(tv)) {
String var_name{tvCastToString(tv)};
wddxPacket->add_var(var_name, true);
}
if (isArrayType(tv->m_type)) {
for (ArrayIter iter(tv->m_data.parr); iter; ++iter) {
find_var_recursive(iter.secondRef().asTypedValue(), wddxPacket);
}
}
}
Variant ArrayUtil::StringUnique(const Array& input) {
Array seenValues;
Array ret = Array::Create();
for (ArrayIter iter(input); iter; ++iter) {
auto const str = tvCastToString(iter.secondVal());
if (!seenValues.exists(str)) {
seenValues.set(str, 1);
ret.set(iter.first(), iter.secondVal());
}
}
return ret;
}
bool MySQLStmtVariables::bind_params(MYSQL_STMT *stmt) {
m_value_arr.clear();
for (int i = 0; i < m_arr.size(); i++) {
MYSQL_BIND *b = &m_vars[i];
auto const var = m_arr.lvalAt(i).unboxed();
Variant v;
if (isNullType(var.type())) {
*b->is_null = 1;
} else {
switch (b->buffer_type) {
case MYSQL_TYPE_LONGLONG:
{
m_value_arr.push_back(cellToInt(var.tv()));
b->buffer = m_value_arr.back().getInt64Data();
}
break;
case MYSQL_TYPE_DOUBLE:
{
m_value_arr.push_back(tvCastToDouble(var.tv()));
b->buffer = m_value_arr.back().getDoubleData();
}
break;
case MYSQL_TYPE_STRING:
{
m_value_arr.push_back(tvCastToString(var.tv()));
StringData *sd = m_value_arr.back().getStringData();
b->buffer = (void *)sd->data();
// FIXME: setting buffer_length will cause the destructor to free
// memory owned by the string
*b->length = sd->size();
}
break;
case MYSQL_TYPE_LONG_BLOB:
// The value are set using send_long_data so we don't have to do
// anything here
break;
default:
assertx(false);
}
}
}
return !mysql_stmt_bind_param(stmt, m_vars);
}
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");
}
}
}
}
}
/* $Id$ */
#include "zend.h"
#include "zend_globals.h"
#include "zend_variables.h"
#include "zend_API.h"
#include "zend_objects.h"
#include "zend_objects_API.h"
#include "zend_object_handlers.h"
#include "zend_interfaces.h"
#include "zend_compile.h"
zval *zend_std_read_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) {
return Z_OBJVAL_P(member)->o_get(
HPHP::String{tvCastToString(member->tv())}
).asRef()->m_data.pref;
}
ZEND_API void zend_std_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC) {
Z_OBJVAL_P(member)->o_set(
HPHP::String{tvCastToString(member->tv())},
tvAsVariant(value->tv())
);
}
zval *zend_std_read_dimension(zval *object, zval *offset, int type TSRMLS_DC) {
zend_class_entry *ce = Z_OBJCE_P(object);
zend_error_noreturn(E_ERROR, "Cannot use object of type %s as array", ce->name);
}
