bool f_pcntl_signal(int signo, const Variant& handler,
bool restart_syscalls /* = true */) {
/* Special long value case for SIG_DFL and SIG_IGN */
if (handler.isInteger()) {
int64_t handle = handler.toInt64();
if (handle != (long)SIG_DFL && handle != (long)SIG_IGN) {
raise_warning("Invalid value for handle argument specified");
}
if (php_signal(signo, (Sigfunc *)handle, restart_syscalls) == SIG_ERR) {
raise_warning("Error assigning signal");
return false;
}
return true;
}
if (!f_is_callable(handler)) {
raise_warning("%s is not a callable function name error",
handler.toString().data());
return false;
}
s_signal_handlers->handlers.set(signo, handler);
if (php_signal(signo, pcntl_signal_handler, restart_syscalls) == SIG_ERR) {
raise_warning("Error assigning signal");
return false;
}
return true;
}
bool HHVM_METHOD(SQLite3, createfunction,
const String& name,
const Variant& callback,
int64_t argcount /* = -1 */) {
auto *data = Native::data<SQLite3>(this_);
data->validate();
if (name.empty()) {
return false;
}
if (!f_is_callable(callback)) {
raise_warning("Not a valid callback function %s",
callback.toString().data());
return false;
}
auto udf = std::make_shared<SQLite3::UserDefinedFunc>();
if (sqlite3_create_function(data->m_raw_db, name.data(), argcount,
SQLITE_UTF8, udf.get(), php_sqlite3_callback_func,
nullptr, nullptr) == SQLITE_OK) {
udf->func = callback;
udf->argc = argcount;
data->m_udfs.push_back(udf);
return true;
}
return false;
}
Variant HHVM_FUNCTION(preg_replace_callback, const Variant& pattern, const Variant& callback,
const Variant& subject,
int limit /* = -1 */,
VRefParam count /* = null */) {
if (!f_is_callable(callback)) {
raise_warning("Not a valid callback function %s",
callback.toString().data());
return empty_string_variant();
}
return preg_replace_impl(pattern, callback, subject,
limit, count, true, false);
}
bool PDOSqliteConnection::createFunction(const String& name,
CVarRef callback,
int argcount) {
if (!f_is_callable(callback)) {
raise_warning("function '%s' is not callable", callback.toString().data());
return false;
}
c_SQLite3::UserDefinedFuncPtr udf(new c_SQLite3::UserDefinedFunc());
auto stat = sqlite3_create_function(m_db, name.data(), argcount, SQLITE_UTF8,
udf.get(), php_sqlite3_callback_func,
nullptr, nullptr);
if (stat != SQLITE_OK) {
return false;
}
udf->func = callback;
udf->argc = argcount;
m_udfs.push_back(udf);
return true;
}
bool c_SQLite3::t_createfunction(const String& name, CVarRef callback,
int64_t argcount /* = -1 */) {
validate();
if (name.empty()) {
return false;
}
if (!f_is_callable(callback)) {
raise_warning("Not a valid callback function %s",
callback.toString().data());
return false;
}
UserDefinedFuncPtr udf(new UserDefinedFunc());
if (sqlite3_create_function(m_raw_db, name.data(), argcount, SQLITE_UTF8,
udf.get(), php_sqlite3_callback_func,
NULL, NULL) == SQLITE_OK) {
udf->func = callback;
udf->argc = argcount;
m_udfs.push_back(udf);
return true;
}
return false;
}
bool
TypeConstraint::check(const TypedValue* tv, const Func* func) const {
assert(hasConstraint());
// This is part of the interpreter runtime; perf matters.
if (tv->m_type == KindOfRef) {
tv = tv->m_data.pref->tv();
}
if (nullable() && IS_NULL_TYPE(tv->m_type)) return true;
if (tv->m_type == KindOfObject) {
if (!isObjectOrTypedef()) return false;
// Perfect match seems common enough to be worth skipping the hash
// table lookup.
if (m_typeName->isame(tv->m_data.pobj->getVMClass()->name())) {
if (shouldProfile()) Class::profileInstanceOf(m_typeName);
return true;
}
const Class *c = nullptr;
const bool selfOrParentOrCallable = isSelf() || isParent() || isCallable();
if (selfOrParentOrCallable) {
if (isSelf()) {
selfToClass(func, &c);
} else if (isParent()) {
parentToClass(func, &c);
} else {
assert(isCallable());
return f_is_callable(tvAsCVarRef(tv));
}
} else {
// We can't save the Class* since it moves around from request
// to request.
assert(m_namedEntity);
c = Unit::lookupClass(m_namedEntity);
}
if (shouldProfile() && c) {
Class::profileInstanceOf(c->preClass()->name());
}
if (c && tv->m_data.pobj->instanceof(c)) {
return true;
}
return !selfOrParentOrCallable && checkTypedefObj(tv);
}
if (isObjectOrTypedef()) {
switch (tv->m_type) {
case KindOfArray:
if (interface_supports_array(m_typeName)) {
return true;
}
break;
case KindOfString:
case KindOfStaticString:
if (interface_supports_string(m_typeName)) {
return true;
}
break;
case KindOfInt64:
if (interface_supports_int(m_typeName)) {
return true;
}
break;
case KindOfDouble:
if (interface_supports_double(m_typeName)) {
return true;
}
break;
default:
break;
}
if (isCallable()) {
return f_is_callable(tvAsCVarRef(tv));
}
return isPrecise() && checkTypedefNonObj(tv);
}
return equivDataTypes(m_type.m_dt, tv->m_type);
}
void VerifyParamTypeCallable(TypedValue value, int param) {
if (UNLIKELY(!f_is_callable(tvAsCVarRef(&value)))) {
VerifyParamTypeFail(param);
}
}
bool TestExtFunction::test_is_callable() {
VERIFY(f_is_callable("TEst"));
// lots of testing in TestCodeRun::TestObjectMethod()
return Count(true);
}
static void xslt_ext_function_php(xmlXPathParserContextPtr ctxt,
int nargs,
int type) {
c_XSLTProcessor *intern = nullptr;
int error = 0;
xsltTransformContextPtr tctxt = xsltXPathGetTransformContext (ctxt);
if (tctxt == nullptr) {
xsltGenericError(xsltGenericErrorContext,
"xsltExtFunctionTest: failed to get the transformation context\n"
);
error = 1;
} else {
intern = (c_XSLTProcessor*)tctxt->_private;
if (intern == nullptr) {
xsltGenericError(xsltGenericErrorContext,
"xsltExtFunctionTest: failed to get the internal object\n"
);
error = 1;
} else {
if (intern->m_registerPhpFunctions == 0) {
xsltGenericError(xsltGenericErrorContext,
"xsltExtFunctionTest: PHP Object did not register PHP functions\n"
);
error = 1;
}
}
}
xmlXPathObjectPtr obj;
if (error == 1) {
for (int i = nargs - 1; i >= 0; i--) {
obj = valuePop(ctxt);
xmlXPathFreeObject(obj);
}
return;
}
Array args;
// Reverse order to pop values off ctxt stack
for (int i = nargs - 2; i >= 0; i--) {
Variant arg;
obj = valuePop(ctxt);
switch (obj->type) {
case XPATH_STRING:
arg = String((char*)obj->stringval, CopyString);
break;
case XPATH_BOOLEAN:
arg = (bool)obj->boolval;
break;
case XPATH_NUMBER:
arg = (double)obj->floatval;
break;
case XPATH_NODESET:
if (type == 1) {
char *str = (char*)xmlXPathCastToString(obj);
arg = String(str, CopyString);
xmlFree(str);
} else if (type == 2) {
arg = Array::Create();
if (obj->nodesetval && obj->nodesetval->nodeNr > 0) {
for (int j = 0; j < obj->nodesetval->nodeNr; j++) {
// TODO: not sure this is the right thing to do.
xmlNodePtr node = obj->nodesetval->nodeTab[j];
if (node->type == XML_ELEMENT_NODE) {
c_DOMElement *elemobj = NEWOBJ(c_DOMElement)();
elemobj->m_node = xmlCopyNode(node, /*extended*/ 1);
arg.toArrRef().append(elemobj);
} else if (node->type == XML_ATTRIBUTE_NODE) {
c_DOMAttr *attrobj = NEWOBJ(c_DOMAttr)();
attrobj->m_node = (xmlNodePtr)xmlCopyProp(nullptr,
(xmlAttrPtr)node);
arg.toArrRef().append(attrobj);
} else if (node->type == XML_TEXT_NODE) {
c_DOMText *textobj = NEWOBJ(c_DOMText)();
textobj->m_node = (xmlNodePtr)xmlNewText(xmlNodeGetContent(node));
arg.toArrRef().append(textobj);
} else {
raise_warning("Unhandled node type '%d'", node->type);
// Use a generic DOMNode as fallback for now.
c_DOMNode *nodeobj = NEWOBJ(c_DOMNode)();
nodeobj->m_node = xmlCopyNode(node, /*extended*/ 1);
arg.toArrRef().append(nodeobj);
}
}
}
}
break;
default:
arg = String((char*)xmlXPathCastToString(obj), CopyString);
}
xmlXPathFreeObject(obj);
args.prepend(arg);
}
obj = valuePop(ctxt);
if (obj->stringval == nullptr) {
raise_warning("Handler name must be a string");
xmlXPathFreeObject(obj);
// Push an empty string to get an xslt result.
valuePush(ctxt, xmlXPathNewString((xmlChar*)""));
return;
}
String handler((char*)obj->stringval, CopyString);
xmlXPathFreeObject(obj);
if (!f_is_callable(handler)) {
raise_warning("Unable to call handler %s()", handler.data());
// Push an empty string to get an xslt result.
valuePush(ctxt, xmlXPathNewString((xmlChar*)""));
} else if (intern->m_registerPhpFunctions == 2 &&
!intern->m_registered_phpfunctions.exists(handler)) {
raise_warning("Not allowed to call handler '%s()'", handler.data());
// Push an empty string to get an xslt result.
valuePush(ctxt, xmlXPathNewString((xmlChar*)""));
} else {
Variant retval = vm_call_user_func(handler, args);
if (retval.isObject() &&
retval.getObjectData()->instanceof(c_DOMNode::classof())) {
xmlNode *nodep = retval.asCObjRef().getTyped<c_DOMNode>()->m_node;
valuePush(ctxt, xmlXPathNewNodeSet(nodep));
} else if (retval.is(KindOfBoolean)) {
valuePush(ctxt, xmlXPathNewBoolean(retval.toBoolean()));
} else if (retval.isObject()) {
raise_warning("A PHP Object cannot be converted to an XPath-string");
// Push an empty string to get an xslt result.
valuePush(ctxt, xmlXPathNewString((xmlChar*)""));
} else {
String sretval = retval.toString();
valuePush(ctxt, xmlXPathNewString((xmlChar*)sretval.data()));
}
}
}
