Variant SSATmp::getValVariant() const { switch (type().toDataType()) { case KindOfUninit: return uninit_null(); case KindOfNull: return init_null(); case KindOfBoolean: return getValBool(); case KindOfInt64: return getValInt(); case KindOfDouble: return getValDbl(); case KindOfString: case KindOfStaticString: return Variant(getValStr()); case KindOfArray: return const_cast<ArrayData*>(getValArr()); default: always_assert(false); } }
Variant f_parse_url(const String& url, int component /* = -1 */) { Url resource; if (!url_parse(resource, url.data(), url.size())) { return false; } if (component > -1) { switch (component) { case k_PHP_URL_SCHEME: RETURN_COMPONENT(scheme); break; case k_PHP_URL_HOST: RETURN_COMPONENT(host); break; case k_PHP_URL_USER: RETURN_COMPONENT(user); break; case k_PHP_URL_PASS: RETURN_COMPONENT(pass); break; case k_PHP_URL_PATH: RETURN_COMPONENT(path); break; case k_PHP_URL_QUERY: RETURN_COMPONENT(query); break; case k_PHP_URL_FRAGMENT: RETURN_COMPONENT(fragment); break; case k_PHP_URL_PORT: if (resource.port) { return resource.port; } break; default: throw_invalid_argument("component: %d", component); return false; } return uninit_null(); } ArrayInit ret(8); SET_COMPONENT(scheme); SET_COMPONENT(host); if (resource.port) { ret.set(s_port, (int64_t)resource.port); } SET_COMPONENT(user); SET_COMPONENT(pass); SET_COMPONENT(path); SET_COMPONENT(query); SET_COMPONENT(fragment); return ret.create(); }
static Variant xml_call_handler(XmlParser *parser, CVarRef handler, CArrRef args) { if (parser && handler) { Variant retval; if (handler.isString()) { if (!parser->object.isObject()) { retval = invoke(handler.toString().c_str(), args, -1); } else { retval = parser->object.toObject()-> o_invoke(handler.toString(), args); } } else if (handler.isArray() && handler.getArrayData()->size() == 2 && (handler[0].isString() || handler[0].isObject()) && handler[1].isString()) { vm_call_user_func(handler, args); } else { raise_warning("Handler is invalid"); } return retval; } return uninit_null(); }
TypedValue* fg_php_check_syntax(ActRec* ar) { TypedValue rvSpace; TypedValue* rv = &rvSpace; int32_t count = ar->numArgs(); TypedValue* args UNUSED = ((TypedValue*)ar) - 1; if (count >= 1 && count <= 2) { if (IS_STRING_TYPE((args - 0)->m_type)) { rv->m_type = KindOfBoolean; VRefParamValue defVal1 = uninit_null(); rv->m_data.num = (fh_php_check_syntax(&args[-0].m_data, (count > 1) ? (args-1) : (TypedValue*)(&defVal1))) ? 1LL : 0LL; } else { fg1_php_check_syntax(rv, ar, count); } } else { throw_wrong_arguments_nr("php_check_syntax", count, 1, 2, 1); rv->m_data.num = 0LL; rv->m_type = KindOfNull; } frame_free_locals_no_this_inl(ar, 2); memcpy(&ar->m_r, rv, sizeof(TypedValue)); return &ar->m_r; }
Variant f_socket_recv(CObjRef socket, VRefParam buf, int len, int flags) { if (len <= 0) { return false; } Socket *sock = socket.getTyped<Socket>(); char *recv_buf = (char *)malloc(len + 1); int retval; if ((retval = recv(sock->fd(), recv_buf, len, flags)) < 1) { free(recv_buf); buf = uninit_null(); } else { recv_buf[retval] = '\0'; buf = String(recv_buf, retval, AttachString); } if (retval == -1) { SOCKET_ERROR(sock, "unable to read from socket", errno); return false; } return retval; }
TypedValue* fg_is_callable(ActRec* ar) { TypedValue rvSpace; TypedValue* rv = &rvSpace; int32_t count = ar->numArgs(); TypedValue* args UNUSED = ((TypedValue*)ar) - 1; if (count >= 1 && count <= 3) { if ((count <= 1 || (args - 1)->m_type == KindOfBoolean)) { rv->m_type = KindOfBoolean; VRefParamValue defVal2 = uninit_null(); rv->m_data.num = (fh_is_callable((args-0), (count > 1) ? (bool)(args[-1].m_data.num) : (bool)(false), (count > 2) ? (args-2) : (TypedValue*)(&defVal2))) ? 1LL : 0LL; } else { fg1_is_callable(rv, ar, count); } } else { throw_wrong_arguments_nr("is_callable", count, 1, 3, 1); rv->m_data.num = 0LL; rv->m_type = KindOfNull; } frame_free_locals_no_this_inl(ar, 3); memcpy(&ar->m_r, rv, sizeof(TypedValue)); return &ar->m_r; }
Variant f_array_map(int _argc, CVarRef callback, CVarRef arr1, CArrRef _argv /* = null_array */) { Array inputs; if (!arr1.isArray()) { throw_bad_array_exception(); return uninit_null(); } inputs.append(arr1); if (!_argv.empty()) { inputs = inputs.merge(_argv); } HPHP::VM::CallCtx ctx; ctx.func = NULL; if (!callback.isNull()) { CallerFrame cf; ctx.func = vm_decode_function(callback, cf(), false, ctx.this_, ctx.cls, ctx.invName); } if (ctx.func == NULL) { return ArrayUtil::Map(inputs, map_func, NULL); } return ArrayUtil::Map(inputs, map_func, &ctx); }
bool TestExtMemcached::test_Memcached_types() { Array list; list.add(s_boolean_true, true); list.add(s_boolean_false, false); list.add(s_string, "just a string"); list.add(s_string_empty, empty_string); list.add(s_integer_positive_integer, 10); list.add(s_integer_negative_integer, -10); list.add(s_integer_zero_integer, 0); list.add(s_float_positive1, 3.912131); list.add(s_float_positive2, 1.2131E+52); list.add(s_float_negative, -42.123312); list.add(s_float_zero, 0.0); list.add(s_null, uninit_null()); list.add(s_array_empty, Array()); list.add(s_array, CREATE_VECTOR4(1, 2, 3, "foo")); CREATE_MEMCACHED(); for (ArrayIter iter(list); iter; ++iter) { VERIFY(memc->t_set(iter.first(), iter.second(), EXPIRATION)); VS(memc->t_get(iter.first()), iter.second()); } for (ArrayIter iter(list); iter; ++iter) { VERIFY(memc->t_delete(iter.first())); } VERIFY(memc->t_setmulti(list, EXPIRATION)); Variant res = memc->t_getmulti(list.keys()); VERIFY(res.isArray()); Array resArray = res.toArray(); VERIFY(resArray->size() == list.size()); for (ArrayIter iter(resArray); iter; ++iter) { VS(iter.second(), list[iter.first()]); } return Count(true); }
Variant f_array_keys(CVarRef input, CVarRef search_value /* = null_variant */, bool strict /* = false */) { const auto& cell_input = *input.asCell(); if (UNLIKELY(!isContainer(cell_input))) { goto warn; } { // We treat Sets differently. For Sets, we pretend the values are // also the keys (similar to how Set::toArray() behaves). bool isSetType = cell_input.m_type == KindOfObject && cell_input.m_data.pobj->getCollectionType() == Collection::SetType; if (UNLIKELY(isSetType)) { return arrayKeysSetHelper(cell_input, search_value, strict); } ArrayIter iter(cell_input); if (LIKELY(!search_value.isInitialized())) { PackedArrayInit ai(getContainerSize(cell_input)); for (; iter; ++iter) { ai.append(iter.first()); } return ai.toArray(); } Array ai = Array::attach(HphpArray::MakeReserve(0)); for (; iter; ++iter) { if ((strict && HPHP::same(iter.secondRefPlus(), search_value)) || (!strict && HPHP::equal(iter.secondRefPlus(), search_value))) { ai.append(iter.first()); } } return ai; } warn: raise_warning("array_keys() expects parameter 1 to be an array " "or collection"); return uninit_null(); }
TypedValue * fg1_apc_dec(TypedValue* rv, HPHP::VM::ActRec* ar, int64_t count) { TypedValue* args UNUSED = ((TypedValue*)ar) - 1; switch (count) { default: // count >= 4 if ((args-3)->m_type != KindOfInt64) { tvCastToInt64InPlace(args-3); } case 3: case 2: if ((args-1)->m_type != KindOfInt64) { tvCastToInt64InPlace(args-1); } case 1: break; } if (!IS_STRING_TYPE((args-0)->m_type)) { tvCastToStringInPlace(args-0); } VRefParamValue defVal2 = uninit_null(); fh_apc_dec((rv), (Value*)(args-0), (count > 1) ? (long)(args[-1].m_data.num) : (long)(1), (count > 2) ? (args-2) : (TypedValue*)(&defVal2), (count > 3) ? (long)(args[-3].m_data.num) : (long)(0)); if (rv->m_type == KindOfUninit) rv->m_type = KindOfNull; return rv; }
bool TestExtOpenssl::test_openssl_seal() { Variant privkey = f_openssl_pkey_new(); VERIFY(!privkey.isNull()); Variant csr = f_openssl_csr_new(uninit_null(), privkey); VERIFY(!csr.isNull()); Variant pubkey = f_openssl_csr_get_public_key(csr); VERIFY(!pubkey.isNull()); String data = "some secret messages"; Variant sealed; Variant ekeys; VERIFY(f_openssl_seal(data, ref(sealed), ref(ekeys), CREATE_VECTOR1(pubkey))); VERIFY(!sealed.toString().empty()); VS(ekeys.toArray().size(), 1); VERIFY(!ekeys[0].toString().empty()); Variant open_data; VERIFY(f_openssl_open(sealed, ref(open_data), ekeys[0], privkey)); VS(open_data, data); return Count(true); }
TypedValue* fg_xml_parse_into_struct(ActRec* ar) { TypedValue rvSpace; TypedValue* rv = &rvSpace; int32_t count = ar->numArgs(); TypedValue* args UNUSED = ((TypedValue*)ar) - 1; if (count >= 3 && count <= 4) { if (IS_STRING_TYPE((args - 1)->m_type) && (args - 0)->m_type == KindOfObject) { rv->m_type = KindOfInt64; VRefParamValue defVal3 = uninit_null(); rv->m_data.num = (int64_t)fh_xml_parse_into_struct(&args[-0].m_data, &args[-1].m_data, (args-2), (count > 3) ? (args-3) : (TypedValue*)(&defVal3)); } else { fg1_xml_parse_into_struct(rv, ar, count); } } else { throw_wrong_arguments_nr("xml_parse_into_struct", count, 3, 4, 1); rv->m_data.num = 0LL; rv->m_type = KindOfNull; } frame_free_locals_no_this_inl(ar, 4); memcpy(&ar->m_r, rv, sizeof(TypedValue)); return &ar->m_r; }
Variant HHVM_FUNCTION(php_uname, const String& mode /*="" */) { struct utsname buf; if (uname((struct utsname *)&buf) == -1) { return uninit_null(); } if (mode == s_s) { return String(buf.sysname, CopyString); } else if (mode == s_r) { return String(buf.release, CopyString); } else if (mode == s_n) { return String(buf.nodename, CopyString); } else if (mode == s_v) { return String(buf.version, CopyString); } else if (mode == s_m) { return String(buf.machine, CopyString); } else { /* assume mode == "a" */ char tmp_uname[512]; snprintf(tmp_uname, sizeof(tmp_uname), "%s %s %s %s %s", buf.sysname, buf.nodename, buf.release, buf.version, buf.machine); return String(tmp_uname, CopyString); } }
ArrayData* PackedArray::Pop(ArrayData* adIn, Variant& value) { assert(checkInvariants(adIn)); auto const ad = adIn->hasMultipleRefs() ? Copy(adIn) : adIn; if (UNLIKELY(ad->m_size == 0)) { value = uninit_null(); ad->m_pos = ArrayData::invalid_index; return ad; } auto const oldSize = ad->m_size; auto& tv = packedData(ad)[oldSize - 1]; value = tvAsCVarRef(&tv); if (UNLIKELY(strong_iterators_exist())) { adjustMArrayIter(ad, oldSize - 1); } auto const oldType = tv.m_type; auto const oldDatum = tv.m_data.num; ad->m_size = oldSize - 1; ad->m_pos = oldSize - 1 > 0 ? 0 : ArrayData::invalid_index; tvRefcountedDecRefHelper(oldType, oldDatum); return ad; }
Variant f_array_column(CVarRef input, CVarRef val_key, CVarRef idx_key /* = null_variant */) { /* Be strict about array type */ getCheckedArrayRet(input, uninit_null()); Variant val = val_key, idx = idx_key; if (!array_column_coerce_key(val, "column") || !array_column_coerce_key(idx, "index")) { return false; } Array ret = Array::Create(); for(auto it = arr_input.begin(); !it.end(); it.next()) { if (!it.second().isArray()) { continue; } Array sub = it.second().toArray(); Variant elem; if (val.isNull()) { elem = sub; } else if (sub.exists(val)) { elem = sub[val]; } else { // skip subarray without named element continue; } if (idx.isNull() || !sub.exists(idx)) { ret.append(elem); } else if (sub[idx].isObject()) { ret.set(sub[idx].toString(), elem); } else { ret.set(sub[idx], elem); } } return ret; }
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) { } } }
Variant throw_fatal_unset_static_property(const char *s, const char *prop) { raise_error("Attempt to unset static property %s::$%s", s, prop); return uninit_null(); }
bool TestExtJson::test_json_decode() { Array arr = CREATE_MAP1("fbid", 101501853510151001LL); VS(f_json_decode(f_json_encode(arr), true), arr); VS(f_json_decode("{\"0\":{\"00\":0}}", true), CREATE_MAP1("0", CREATE_MAP1("00", 0))); VS(f_json_decode("{\"a\":1,\"b\":2.3,\"3\":\"test\"}", true), CREATE_MAP3("a", 1, "b", 2.3, 3, "test")); VS(f_json_decode("[\"a\",1,true,false,null]", true), CREATE_VECTOR5("a", 1, true, false, uninit_null())); Object obj = f_json_decode("{\"a\":1,\"b\":2.3,\"3\":\"test\"}"); Object obj2(SystemLib::AllocStdClassObject()); obj2->o_set("a", 1); obj2->o_set("b", 2.3); obj2->o_set("3", "test"); VS(obj.toArray(), obj2.toArray()); obj = f_json_decode("[\"a\",1,true,false,null]"); VS(obj.toArray(), CREATE_VECTOR5("a", 1, true, false, uninit_null())); VS(f_json_decode("{z:1}", true), uninit_null()); VS(f_json_decode("{z:1}", true, k_JSON_FB_LOOSE), CREATE_MAP1("z", 1)); VS(f_json_decode("{z:\"z\"}", true), uninit_null()); VS(f_json_decode("{z:\"z\"}", true, k_JSON_FB_LOOSE), CREATE_MAP1("z", "z")); VS(f_json_decode("{'x':1}", true), uninit_null()); VS(f_json_decode("{'x':1}", true, k_JSON_FB_LOOSE), CREATE_MAP1("x", 1)); VS(f_json_decode("{y:1,}", true), uninit_null()); VS(f_json_decode("{y:1,}", true, k_JSON_FB_LOOSE), CREATE_MAP1("y", 1)); VS(f_json_decode("{,}", true), uninit_null()); VS(f_json_decode("{,}", true, k_JSON_FB_LOOSE), uninit_null()); VS(f_json_decode("[1,2,3,]", true), uninit_null()); VS(f_json_decode("[1,2,3,]", true, k_JSON_FB_LOOSE), CREATE_VECTOR3(1,2,3)); VS(f_json_decode("[,]", true), uninit_null()); VS(f_json_decode("[,]", true, k_JSON_FB_LOOSE), uninit_null()); VS(f_json_decode("[]", true), Array::Create()); VS(f_json_decode("[]", true, k_JSON_FB_LOOSE), Array::Create()); VS(f_json_decode("{}", true), Array::Create()); VS(f_json_decode("{}", true, k_JSON_FB_LOOSE), Array::Create()); VS(f_json_decode("[{\"a\":\"apple\"},{\"b\":\"banana\"}]", true), CREATE_VECTOR2(CREATE_MAP1("a", "apple"), CREATE_MAP1("b", "banana"))); Variant a = "[{\"a\":[{\"n\":\"1st\"}]},{\"b\":[{\"n\":\"2nd\"}]}]"; VS(f_json_decode(a, true), CREATE_VECTOR2 (CREATE_MAP1("a", CREATE_VECTOR1(CREATE_MAP1("n", "1st"))), CREATE_MAP1("b", CREATE_VECTOR1(CREATE_MAP1("n", "2nd"))))); return Count(true); }
void DummySandbox::run() { TRACE(2, "DummySandbox::run\n"); ThreadInfo *ti = ThreadInfo::s_threadInfo.getNoCheck(); Debugger::RegisterThread(); while (!m_stopped) { try { CLISession hphpSession; DSandboxInfo sandbox = m_proxy->getSandbox(); string msg; if (sandbox.valid()) { GlobalVariables *g = get_global_variables(); 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 { sri.setServerVariables(g->getRef(s__SERVER)); } 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; string errorMsg; bool ret = hphp_invoke(g_context.getNoCheck(), doc, false, null_array, uninit_null(), "", "", error, errorMsg, true, false, true); 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()); } ti->m_reqInjectionData.setDebugger(true); { 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) { } } }
Variant MySQLResult::getField(int64_t field) const { if (!m_localized || field < 0 || field >= (int64_t)m_current_row->size()) { return uninit_null(); } return (*m_current_row)[field]; }
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); SystemGlobals *g = (SystemGlobals*)get_global_variables(); g->GV(_ENV).set(s_HPHP_RPC, 1); } 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 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(m_returnEncodeType == Json || m_returnEncodeType == Serialize); try { response = (m_returnEncodeType == Json) ? f_json_encode(funcRet) : f_serialize(funcRet); } catch (...) { serializeFailed = true; } break; } case 1: response = m_context->obDetachContents(); break; case 2: response = f_json_encode(CREATE_MAP2(s_output, m_context->obDetachContents(), s_return, f_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; }
Variant& lvalBlackHole() { auto& bh = get_env_constants()->lvalProxy; bh = uninit_null(); return bh; }
static void json_create_zval(Variant &z, StringBuffer &buf, int type, int64_t options) { switch (type) { case KindOfBoolean: z = (buf.data() && (*buf.data() == 't')); return; case KindOfInt64: { bool bigint = false; const char *p = buf.data(); assert(p); if (p == NULL) { z = int64_t(0); return; } bool neg = *buf.data() == '-'; int len = buf.size(); if (neg) len--; if (len >= MAX_LENGTH_OF_LONG - 1) { if (len == MAX_LENGTH_OF_LONG - 1) { int cmp = strcmp(p + (neg ? 1 : 0), long_min_digits); if (!(cmp < 0 || (cmp == 0 && neg))) { bigint = true; } } else { bigint = true; } } if (bigint) { if (!(options & k_JSON_BIGINT_AS_STRING)) { // See KindOfDouble (below) z = to_double(buf); } else { z = copy_and_clear(buf); } } else { z = int64_t(strtoll(buf.data(), nullptr, 10)); } return; } case KindOfDouble: // Use zend_strtod() instead of strtod() here since JSON specifies using // a '.' for decimal separators regardless of locale. z = to_double(buf); return; case KindOfString: z = copy_and_clear(buf); return; case KindOfUninit: case KindOfNull: case KindOfStaticString: case KindOfArray: case KindOfObject: case KindOfResource: case KindOfRef: z = uninit_null(); return; case KindOfClass: break; } not_reached(); }
Variant c_XMLReader::t___destruct() { return uninit_null(); }
static Variant warn_non_object() { raise_notice("Cannot access property on non-object"); return uninit_null(); }
Variant f_json_decode(const String& json, bool assoc /* = false */, CVarRef options /* = 0 */) { json_set_last_error_code(json_error_codes::JSON_ERROR_NONE); if (json.empty()) { return uninit_null(); } int64_t json_options = options.toInt64(); if (options.isBoolean() && options.toBooleanVal()) { json_options = k_JSON_FB_LOOSE; } const int64_t supported_options = k_JSON_FB_LOOSE | k_JSON_FB_COLLECTIONS | k_JSON_FB_STABLE_MAPS; int64_t parser_options = json_options & supported_options; Variant z; if (JSON_parser(z, json.data(), json.size(), assoc, parser_options)) { return z; } if (json.size() == 4) { if (!strcasecmp(json.data(), "null")) { json_set_last_error_code(json_error_codes::JSON_ERROR_NONE); return uninit_null(); } if (!strcasecmp(json.data(), "true")) { json_set_last_error_code(json_error_codes::JSON_ERROR_NONE); return true; } } else if (json.size() == 5 && !strcasecmp(json.data(), "false")) { json_set_last_error_code(json_error_codes::JSON_ERROR_NONE); return false; } int64_t p; double d; DataType type = json->isNumericWithVal(p, d, 0); if (type == KindOfInt64) { json_set_last_error_code(json_error_codes::JSON_ERROR_NONE); return p; } else if (type == KindOfDouble) { json_set_last_error_code(json_error_codes::JSON_ERROR_NONE); return d; } char ch0 = json.charAt(0); if (json.size() > 1 && ch0 == '"' && json.charAt(json.size() - 1) == '"') { json_set_last_error_code(json_error_codes::JSON_ERROR_NONE); // Wrap the string in an array to allow the JSON_parser to handle // things like unicode escape sequences, then unwrap to get result String wrapped("["); wrapped += json + "]"; // Stick to a normal hhvm array for the wrapper const int64_t mask = ~(k_JSON_FB_COLLECTIONS | k_JSON_FB_STABLE_MAPS); if (JSON_parser(z, wrapped.data(), wrapped.size(), false, parser_options & mask) && z.isArray()) { Array arr = z.toArray(); if ((arr.size() == 1) && arr.exists(0)) { return arr[0]; } // The input string could be something like: "foo","bar" // Which will parse inside the [] wrapper, but be invalid json_set_last_error_code(json_error_codes::JSON_ERROR_SYNTAX); } } if ((json_options & k_JSON_FB_LOOSE) && json.size() > 1 && ch0 == '\'' && json.charAt(json.size() - 1) == '\'') { json_set_last_error_code(json_error_codes::JSON_ERROR_NONE); return json.substr(1, json.size() - 2); } if (ch0 == '{' || ch0 == '[') { /* invalid JSON string */ json_set_last_error_code(json_error_codes::JSON_ERROR_SYNTAX); } assert(json_get_last_error_code() != json_error_codes::JSON_ERROR_NONE); return uninit_null(); }
static Variant HHVM_FUNCTION(SystemLib_assert, const Variant& assertion, const Variant& message = uninit_null()) { return impl_assert(assertion, message); }
Variant c_Normalizer::ti_normalize(const String& input, int64_t form /* = q_Normalizer$$FORM_C */) { s_intl_error->m_error.clear(); int expansion_factor = 1; switch(form) { case UNORM_NONE: case UNORM_NFC: case UNORM_NFKC: break; case UNORM_NFD: case UNORM_NFKD: expansion_factor = 3; break; default: s_intl_error->m_error.code = U_ILLEGAL_ARGUMENT_ERROR; s_intl_error->m_error.custom_error_message = "normalizer_normalize: illegal normalization form"; return uninit_null(); } /* First convert the string to UTF-16. */ UChar* uinput = NULL; int uinput_len = 0; UErrorCode status = U_ZERO_ERROR; intl_convert_utf8_to_utf16(&uinput, &uinput_len, input.data(), input.size(), &status); if (U_FAILURE(status)) { s_intl_error->m_error.code = status; s_intl_error->m_error.custom_error_message = "Error converting string to UTF-16."; free(uinput); return uninit_null(); } /* Allocate memory for the destination buffer for normalization */ int uret_len = uinput_len * expansion_factor; UChar *uret_buf = (UChar*)malloc((uret_len + 1) * sizeof(UChar)); /* normalize */ int size_needed = unorm_normalize(uinput, uinput_len, (UNormalizationMode)form, (int32_t) 0, uret_buf, uret_len, &status); /* Bail out if an unexpected error occured. * (U_BUFFER_OVERFLOW_ERROR means that *target buffer is not large enough). * (U_STRING_NOT_TERMINATED_WARNING usually means that the input string * is empty). */ if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR && status != U_STRING_NOT_TERMINATED_WARNING) { free(uret_buf); free(uinput); return uninit_null(); } if (size_needed > uret_len) { /* realloc does not seem to work properly - memory is corrupted * uret_buf = eurealloc(uret_buf, size_needed + 1); */ free(uret_buf); uret_buf = (UChar*)malloc((size_needed + 1) * sizeof(UChar)); uret_len = size_needed; status = U_ZERO_ERROR; /* try normalize again */ size_needed = unorm_normalize( uinput, uinput_len, (UNormalizationMode)form, (int32_t) 0, uret_buf, uret_len, &status); /* Bail out if an unexpected error occured. */ if (U_FAILURE(status)) { /* Set error messages. */ s_intl_error->m_error.code = status; s_intl_error->m_error.custom_error_message = "Error normalizing string"; free(uret_buf); free(uinput); return uninit_null(); } } free(uinput); /* the buffer we actually used */ uret_len = size_needed; /* Convert normalized string from UTF-16 to UTF-8. */ char* ret_buf = NULL; int ret_len = 0; intl_convert_utf16_to_utf8(&ret_buf, &ret_len, uret_buf, uret_len, &status); free(uret_buf); if (U_FAILURE(status)) { s_intl_error->m_error.code = status; s_intl_error->m_error.custom_error_message = "normalizer_normalize: error converting normalized text UTF-8"; return uninit_null(); } return String(ret_buf, ret_len, AttachString); }
Variant c_Memcache::t___destruct() { t_close(); return uninit_null(); }
Variant c_DummyContinuation::t_current() { throw_fatal("Tring to use a DummyContinuation"); return uninit_null(); }