Variant c_Memcached::t_getmultibykey(CStrRef server_key, CArrRef keys,
VRefParam cas_tokens /*= null_variant*/,
int flags /*= 0*/) {
INSTANCE_METHOD_INJECTION_BUILTIN(Memcached, Memcached::getmultibykey);
m_impl->rescode = q_Memcached_RES_SUCCESS;
bool preserveOrder = flags & q_Memcached_GET_PRESERVE_ORDER;
Array returnValue;
if (!getMultiImpl(server_key, keys, cas_tokens.isReferenced(),
preserveOrder ? &returnValue : NULL)) {
return false;
}
if (cas_tokens.isReferenced()) cas_tokens = Array();
MemcachedResultWrapper result(&m_impl->memcached);
memcached_return status;
while (memcached_fetch_result(&m_impl->memcached, &result.value, &status)) {
Variant value;
if (!toObject(value, result.value)) {
m_impl->rescode = q_Memcached_RES_PAYLOAD_FAILURE;
return false;
}
const char *key = memcached_result_key_value(&result.value);
size_t keyLength = memcached_result_key_length(&result.value);
String sKey(key, keyLength, CopyString);
returnValue.set(sKey, value, true);
if (cas_tokens.isReferenced()) {
double cas = (double) memcached_result_cas(&result.value);
cas_tokens->set(sKey, cas, true);
}
}
if (status != MEMCACHED_END && !handleError(status)) return false;
return returnValue;
}
Variant f_preg_match_all(CStrRef pattern, CStrRef subject, VRefParam matches,
int flags /* = 0 */, int offset /* = 0 */) {
if (matches.isReferenced()) {
return preg_match_all(pattern, subject, matches, flags, offset);
} else {
return preg_match_all(pattern, subject, flags, offset);
}
}
Variant HHVM_FUNCTION(preg_match, const String& pattern, const String& subject,
VRefParam matches /* = null */,
int flags /* = 0 */, int offset /* = 0 */) {
if (matches.isReferenced()) {
return preg_match(pattern, subject, matches, flags, offset);
} else {
return preg_match(pattern, subject, flags, offset);
}
}
static void parse_str_impl(const String& str, VRefParam arr) {
Array result = Array::Create();
HttpProtocol::DecodeParameters(result, str.data(), str.size());
if (!arr.isReferenced()) {
HHVM_FN(SystemLib_extract)(result);
return;
}
arr.assignIfRef(result);
}
Variant c_Memcached::t_getbykey(CStrRef server_key, CStrRef key,
CVarRef cache_cb /*= null_variant*/,
VRefParam cas_token /*= null_variant*/) {
INSTANCE_METHOD_INJECTION_BUILTIN(Memcached, Memcached::getbykey);
m_impl->rescode = q_Memcached_RES_SUCCESS;
if (key.empty()) {
m_impl->rescode = q_Memcached_RES_BAD_KEY_PROVIDED;
return false;
}
memcached_behavior_set(&m_impl->memcached, MEMCACHED_BEHAVIOR_SUPPORT_CAS,
cas_token.isReferenced() ? 1 : 0);
const char *myServerKey = server_key.empty() ? NULL : server_key.c_str();
size_t myServerKeyLen = server_key.length();
const char *myKey = key.c_str();
size_t myKeyLen = key.length();
memcached_return status = memcached_mget_by_key(&m_impl->memcached,
myServerKey, myServerKeyLen, &myKey, &myKeyLen, 1);
if (!handleError(status)) return false;
Variant returnValue;
MemcachedResultWrapper result(&m_impl->memcached);
if (!memcached_fetch_result(&m_impl->memcached, &result.value, &status)) {
if (status == MEMCACHED_END) status = MEMCACHED_NOTFOUND;
if (status == MEMCACHED_NOTFOUND && !cache_cb.isNull()) {
status = doCacheCallback(cache_cb, key, returnValue);
if (!handleError(status)) return false;
if (cas_token.isReferenced()) cas_token = 0.0;
return returnValue;
}
handleError(status);
return false;
}
if (!toObject(returnValue, result.value)) {
m_impl->rescode = q_Memcached_RES_PAYLOAD_FAILURE;
return false;
}
if (cas_token.isReferenced()) {
cas_token = (double) memcached_result_cas(&result.value);
}
return returnValue;
}
static bool HHVM_STATIC_METHOD(EventUtil, getSocketName, const Resource &socket, VRefParam address, VRefParam port){
evutil_socket_t fd = resource_to_fd(socket);
struct sockaddr sa;
socklen_t sa_len = sizeof(struct sockaddr);
long l_port = 0;
if (getsockname(fd, &sa, &sa_len)) {
raise_warning("Unable to retreive socket name.");
return false;
}
switch (sa.sa_family) {
case AF_INET:
{
struct sockaddr_in *sa_in = (struct sockaddr_in *) &sa;
char c_addr[INET_ADDRSTRLEN + 1];
if (evutil_inet_ntop(sa.sa_family, &sa_in->sin_addr, c_addr, sizeof(c_addr))) {
address = StringData::Make(c_addr, CopyString);
l_port = ntohs(sa_in->sin_port);
}
}
break;
#ifdef AF_INET6
case AF_INET6: {
struct sockaddr_in6 *sa_in6 = (struct sockaddr_in6 *) &sa;
char c_addr6[INET6_ADDRSTRLEN + 1];
if (evutil_inet_ntop(sa.sa_family, &sa_in6->sin6_addr, c_addr6, sizeof(c_addr6))) {
address = StringData::Make(c_addr6, CopyString);
l_port = ntohs(sa_in6->sin6_port);
}
break;
}
#endif
#ifdef HAVE_SYS_UN_H
case AF_UNIX: {
struct sockaddr_un *ua = (struct sockaddr_un *) &sa;
address = StringData::Make(ua->sun_path, CopyString);
break;
}
#endif
default:
raise_warning("Unsupported address family.");
return false;
}
if(port.isReferenced()){
port = l_port;
}
return true;
}
static Variant preg_replace_callback_array_impl(
const Variant& patterns_and_callbacks,
const Array& subjects,
int limit,
VRefParam count) {
Array ret = Array::Create();
auto key = 0;
auto total_replacement_count = 0;
for (ArrayIter s_iter(subjects); s_iter; ++s_iter) {
assert(s_iter.second().isString());
auto subj = s_iter.second();
for (ArrayIter pc_iter(patterns_and_callbacks.toArray());
pc_iter; ++pc_iter) {
Variant pattern(pc_iter.first());
assert(pattern.isString());
Variant callback(pc_iter.second());
subj = HHVM_FN(preg_replace_callback)(pattern, callback, subj, limit,
count);
// If we got an error on the replacement, the subject will be null,
// and then we will return null.
if (subj.isNull()) {
return init_null();
}
if (count.isReferenced()) {
total_replacement_count += count.toInt64();
}
}
ret.add(key++, subj);
}
// If count was passed in as an explicit reference, we will assign it to our
// total replacement count; otherwise, count will just remained unassigned
count.assignIfRef(total_replacement_count);
// If there were no replacements (i.e., matches) return original subject(s)
if (ret.empty()) {
return subjects;
}
return ret;
}
bool f_is_callable(CVarRef v, bool syntax /* = false */,
VRefParam name /* = null */) {
bool ret = true;
if (LIKELY(!syntax)) {
CallerFrame cf;
ObjectData* obj = NULL;
HPHP::Class* cls = NULL;
StringData* invName = NULL;
const HPHP::Func* f = vm_decode_function(v, cf(), false, obj, cls,
invName, false);
if (f == NULL) {
ret = false;
}
if (invName != NULL) {
decRefStr(invName);
}
if (!name.isReferenced()) return ret;
}
auto const tv_func = v.asCell();
if (IS_STRING_TYPE(tv_func->m_type)) {
if (name.isReferenced()) name = tv_func->m_data.pstr;
return ret;
}
if (tv_func->m_type == KindOfArray) {
CArrRef arr = tv_func->m_data.parr;
CVarRef clsname = arr.rvalAtRef(int64_t(0));
CVarRef mthname = arr.rvalAtRef(int64_t(1));
if (arr.size() != 2 ||
&clsname == &null_variant ||
&mthname == &null_variant) {
name = v.toString();
return false;
}
auto const tv_meth = mthname.asCell();
if (!IS_STRING_TYPE(tv_meth->m_type)) {
if (name.isReferenced()) name = v.toString();
return false;
}
auto const tv_cls = clsname.asCell();
if (tv_cls->m_type == KindOfObject) {
name = tv_cls->m_data.pobj->o_getClassName();
} else if (IS_STRING_TYPE(tv_cls->m_type)) {
name = tv_cls->m_data.pstr;
} else {
name = v.toString();
return false;
}
name = concat3(name, s_colon2, tv_meth->m_data.pstr);
return ret;
}
if (tv_func->m_type == KindOfObject) {
ObjectData *d = tv_func->m_data.pobj;
const Func* invoke = d->getVMClass()->lookupMethod(s__invoke.get());
if (name.isReferenced()) {
if (d->instanceof(c_Closure::classof())) {
// Hack to stop the mangled name from showing up
name = s_Closure__invoke;
} else {
name = d->o_getClassName() + "::__invoke";
}
}
return invoke != NULL;
}
return false;
}
bool HHVM_FUNCTION(is_callable, const Variant& v, bool syntax /* = false */,
VRefParam name /* = null */) {
return is_callable(v, syntax, name.isReferenced() ?
name.wrapped().asTypedValue()->m_data.pref : nullptr);
}
bool f_is_callable(CVarRef v, bool syntax /* = false */,
VRefParam name /* = null */) {
bool ret = true;
if (LIKELY(!syntax)) {
if (hhvm) {
CallerFrame cf;
ObjectData* obj = NULL;
HPHP::VM::Class* cls = NULL;
StringData* invName = NULL;
const HPHP::VM::Func* f = vm_decode_function(v, cf(), false, obj, cls,
invName, false);
if (f == NULL) {
ret = false;
}
if (invName != NULL) {
LITSTR_DECREF(invName);
}
} else {
MethodCallPackage mcp;
String classname, methodname;
bool doBind;
ret = get_user_func_handler(v, true, mcp,
classname, methodname, doBind, false);
if (ret && mcp.ci->m_flags & (CallInfo::Protected|CallInfo::Private)) {
classname = mcp.getClassName();
if (!ClassInfo::HasAccess(classname, *mcp.name,
mcp.ci->m_flags & CallInfo::StaticMethod ||
!mcp.obj,
mcp.obj)) {
ret = false;
}
}
}
if (!name.isReferenced()) return ret;
}
Variant::TypedValueAccessor tv_func = v.getTypedAccessor();
if (Variant::IsString(tv_func)) {
if (name.isReferenced()) name = Variant::GetStringData(tv_func);
return ret;
}
if (Variant::GetAccessorType(tv_func) == KindOfArray) {
CArrRef arr = Variant::GetAsArray(tv_func);
CVarRef clsname = arr.rvalAtRef(0LL);
CVarRef mthname = arr.rvalAtRef(1LL);
if (arr.size() != 2 ||
&clsname == &null_variant ||
&mthname == &null_variant) {
name = v.toString();
return false;
}
Variant::TypedValueAccessor tv_meth = mthname.getTypedAccessor();
if (!Variant::IsString(tv_meth)) {
if (name.isReferenced()) name = v.toString();
return false;
}
Variant::TypedValueAccessor tv_cls = clsname.getTypedAccessor();
if (Variant::GetAccessorType(tv_cls) == KindOfObject) {
name = Variant::GetObjectData(tv_cls)->o_getClassName();
} else if (Variant::IsString(tv_cls)) {
name = Variant::GetStringData(tv_cls);
} else {
name = v.toString();
return false;
}
name = concat3(name, "::", Variant::GetAsString(tv_meth));
return ret;
}
if (Variant::GetAccessorType(tv_func) == KindOfObject) {
ObjectData *d = Variant::GetObjectData(tv_func);
if (hhvm) {
static const StringData* sd__invoke
= StringData::GetStaticString("__invoke");
const VM::Func* invoke = d->getVMClass()->lookupMethod(sd__invoke);
if (name.isReferenced()) {
if (d->o_instanceof("closure")) {
// Hack to stop the mangled name from showing up
name = "Closure::__invoke";
} else {
name = d->o_getClassName() + "::__invoke";
}
}
return invoke != NULL;
} else {
void *extra;
if (d->t___invokeCallInfoHelper(extra)) {
name = d->o_getClassName() + "::__invoke";
return ret;
}
if (name.isReferenced()) {
name = v.toString();
}
}
}
return false;
}
Variant f_icu_match(CStrRef pattern, CStrRef subject,
VRefParam matches /* = null */, int64_t flags /* = 0 */) {
UErrorCode status = U_ZERO_ERROR;
if (matches.isReferenced()) {
matches = Array();
}
// Create hash map key by concatenating pattern and flags.
StringBuffer bpattern;
bpattern.append(pattern);
bpattern.append(':');
bpattern.append(flags);
String spattern = bpattern.detach();
// Find compiled pattern matcher in hash map or add it.
PatternStringMap::accessor accessor;
const RegexPattern* rpattern;
if (s_patternCacheMap.find(accessor, spattern.get())) {
rpattern = accessor->second;
} else {
// First 32 bits are reserved for ICU-specific flags.
rpattern = RegexPattern::compile(
UnicodeString::fromUTF8(pattern.data()), (flags & 0xFFFFFFFF), status);
if (U_FAILURE(status)) {
return false;
}
if (s_patternCacheMap.insert(
accessor, StringData::GetStaticString(spattern.get()))) {
accessor->second = rpattern;
} else {
delete rpattern;
rpattern = accessor->second;
}
}
// Build regex matcher from compiled pattern and passed-in subject.
UnicodeString usubject = UnicodeString::fromUTF8(subject.data());
boost::scoped_ptr<RegexMatcher> matcher(rpattern->matcher(usubject, status));
if (U_FAILURE(status)) {
return false;
}
// Return 0 or 1 depending on whether or not a match was found and
// (optionally), set matched (sub-)patterns for passed-in reference.
int matched = 0;
if (matcher->find()) {
matched = 1;
if (matches.isReferenced()) {
int32_t count = matcher->groupCount();
for (int32_t i = 0; i <= count; i++) {
UnicodeString ustring = matcher->group(i, status);
if (U_FAILURE(status)) {
return false;
}
// Convert UnicodeString back to UTF-8.
std::string string;
ustring.toUTF8String(string);
String match = String(string);
if (flags & k_UREGEX_OFFSET_CAPTURE) {
// start() returns the index in UnicodeString, which
// normally means the index into an array of 16-bit
// code "units" (not "points").
int32_t start = matcher->start(i, status);
if (U_FAILURE(status)) {
return false;
}
start = usubject.countChar32(0, start);
matches->append(CREATE_VECTOR2(match, start));
} else {
matches->append(match);
}
}
}
}
return matched;
}
bool f_is_callable(CVarRef v, bool syntax /* = false */,
VRefParam name /* = null */) {
if (v.isString()) {
if (name.isReferenced()) name = v;
if (syntax) return true;
String str = v.toString();
int c = str.find("::");
if (c != 0 && c != String::npos && c + 2 < str.size()) {
String classname = str.substr(0, c);
String methodname = str.substr(c + 2);
return f_class_exists(classname) &&
ClassInfo::HasAccess(classname, methodname, true, false);
}
return f_function_exists(str);
}
if (v.is(KindOfArray)) {
Array arr = v.toArray();
if (arr.size() == 2 && arr.exists(0LL) && arr.exists(1LL)) {
Variant v0 = arr.rvalAt(0LL);
Variant v1 = arr.rvalAt(1LL);
Object obj;
bool staticCall = false;
if (v0.is(KindOfObject)) {
obj = v0.toObject();
v0 = obj->o_getClassName();
} else if (v0.isString()) {
if (!f_class_exists(v0.toString())) {
return false;
}
staticCall = true;
}
if (v1.isString()) {
String str = v1.toString();
int c = str.find("::");
if (c != 0 && c != String::npos && c + 2 < str.size()) {
String name1 = v0.toString();
String name2 = str.substr(0, c);
ASSERT(name1.get() && name2.get());
if (name1->isame(name2.get()) ||
ClassInfo::IsSubClass(name1, name2, false)) {
staticCall = true;
v0 = name2;
v1 = str.substr(c + 2);
}
}
}
if (v0.isString() && v1.isString()) {
if (name.isReferenced()) {
name = v0.toString() + "::" + v1.toString();
}
if (same(v0, s_self) || same(v0, s_parent)) {
throw NotImplementedException("augmenting class scope info");
}
return ClassInfo::HasAccess(v0, v1, staticCall, !obj.isNull());
}
}
}
if (v.isObject()) {
ObjectData *d = v.objectForCall();
if (name.isReferenced()) {
name = d->o_getClassName() + "::__invoke";
}
void *extra;
const CallInfo *cit = d->t___invokeCallInfoHelper(extra);
return cit != NULL;
}
if (name.isReferenced()) {
name = v.toString();
}
return false;
}
bool f_is_callable(CVarRef v, bool syntax /* = false */,
VRefParam name /* = null */) {
bool ret = true;
if (LIKELY(!syntax)) {
CallerFrame cf;
ObjectData* obj = NULL;
HPHP::VM::Class* cls = NULL;
StringData* invName = NULL;
const HPHP::VM::Func* f = vm_decode_function(v, cf(), false, obj, cls,
invName, false);
if (f == NULL) {
ret = false;
}
if (invName != NULL) {
decRefStr(invName);
}
if (!name.isReferenced()) return ret;
}
Variant::TypedValueAccessor tv_func = v.getTypedAccessor();
if (Variant::IsString(tv_func)) {
if (name.isReferenced()) name = Variant::GetStringData(tv_func);
return ret;
}
if (Variant::GetAccessorType(tv_func) == KindOfArray) {
CArrRef arr = Variant::GetAsArray(tv_func);
CVarRef clsname = arr.rvalAtRef(int64_t(0));
CVarRef mthname = arr.rvalAtRef(int64_t(1));
if (arr.size() != 2 ||
&clsname == &null_variant ||
&mthname == &null_variant) {
name = v.toString();
return false;
}
Variant::TypedValueAccessor tv_meth = mthname.getTypedAccessor();
if (!Variant::IsString(tv_meth)) {
if (name.isReferenced()) name = v.toString();
return false;
}
Variant::TypedValueAccessor tv_cls = clsname.getTypedAccessor();
if (Variant::GetAccessorType(tv_cls) == KindOfObject) {
name = Variant::GetObjectData(tv_cls)->o_getClassName();
} else if (Variant::IsString(tv_cls)) {
name = Variant::GetStringData(tv_cls);
} else {
name = v.toString();
return false;
}
name = concat3(name, "::", Variant::GetAsString(tv_meth));
return ret;
}
if (Variant::GetAccessorType(tv_func) == KindOfObject) {
ObjectData *d = Variant::GetObjectData(tv_func);
static const StringData* sd__invoke
= StringData::GetStaticString("__invoke");
const VM::Func* invoke = d->getVMClass()->lookupMethod(sd__invoke);
if (name.isReferenced()) {
if (d->instanceof(c_Closure::s_cls)) {
// Hack to stop the mangled name from showing up
name = "Closure::__invoke";
} else {
name = d->o_getClassName() + "::__invoke";
}
}
return invoke != NULL;
}
return false;
}