String HHVM_FUNCTION(gethostbyname, const String& hostname) {
IOStatusHelper io("gethostbyname", hostname.data());
if (RuntimeOption::EnableDnsCache) {
Variant success;
Variant resolved = f_apc_fetch(hostname, ref(success),
SHARED_STORE_DNS_CACHE);
if (same(success, true)) {
if (same(resolved, false)) {
return hostname;
}
return resolved.toString();
}
}
HostEnt result;
if (!safe_gethostbyname(hostname.data(), result)) {
if (RuntimeOption::EnableDnsCache) {
f_apc_store(hostname, false, RuntimeOption::DnsCacheTTL,
SHARED_STORE_DNS_CACHE);
}
return hostname;
}
struct in_addr in;
memcpy(&in.s_addr, *(result.hostbuf.h_addr_list), sizeof(in.s_addr));
String ret(safe_inet_ntoa(in));
if (RuntimeOption::EnableDnsCache) {
f_apc_store(hostname, ret, RuntimeOption::DnsCacheTTL,
SHARED_STORE_DNS_CACHE);
}
return ret;
}
bool TestExtApc::test_apc_clear_cache() {
f_apc_store("ts", "TestString");
f_apc_store("ta", CREATE_MAP2("a", 1, "b", 2));
f_apc_clear_cache();
VS(f_apc_fetch("ts"), false);
VS(f_apc_fetch("ta"), false);
VS(f_apc_fetch("ts"), false);
VS(f_apc_fetch("ta"), false);
return Count(true);
}
bool TestExtApc::test_apc_exists() {
f_apc_store("ts", "TestString");
VS(f_apc_exists("ts"), true);
VS(f_apc_exists("TestString"), false);
VS(f_apc_exists(CREATE_VECTOR2("ts", "TestString")), CREATE_VECTOR1("ts"));
return Count(true);
}
bool TestExtApc::test_apc_dec() {
f_apc_store("ts", 12);
VS(f_apc_dec("ts"), 11);
VS(f_apc_dec("ts", 5), 6);
VS(f_apc_dec("ts", -3), 9);
return Count(true);
}
bool TestExtApc::test_apc_inc() {
f_apc_store("ts", 12);
VS(f_apc_inc("ts"), 13);
VS(f_apc_inc("ts", 5), 18);
VS(f_apc_inc("ts", -3), 15);
return Count(true);
}
xmlDocPtr soap_xmlParseFile(const char *filename) {
String cache_key("HPHP.SOAP.WSDL.");
cache_key += filename;
Variant content = f_apc_fetch(cache_key);
if (same(content, false)) {
Variant stream = File::Open(filename, "rb", CREATE_MAP1
("http", CREATE_MAP1("timeout", 1000)));
if (!same(stream, false)) {
content = f_stream_get_contents(stream);
if (!same(content, false)) {
f_apc_store(cache_key, content);
}
}
}
if (!same(content, false)) {
String scontent = content.toString();
xmlDocPtr ret = soap_xmlParseMemory(scontent.data(), scontent.size());
if (ret) {
ret->URL = xmlCharStrdup(filename);
}
return ret;
}
return NULL;
}
bool TestExtApc::test_apc_exists() {
f_apc_store(s_ts, s_TestString);
VS(f_apc_exists(s_ts), true);
VS(f_apc_exists(s_TestString), false);
VS(f_apc_exists(CREATE_VECTOR2(s_ts, s_TestString)), CREATE_VECTOR1(s_ts));
return Count(true);
}
xmlDocPtr soap_xmlParseFile(const char *filename) {
String cache_key("HPHP.SOAP.WSDL.");
cache_key += filename;
Variant content = f_apc_fetch(cache_key);
if (same(content, false)) {
Resource resource = File::Open(filename, "rb", 0, f_stream_context_create(
make_map_array(s_http, make_map_array(s_timeout, 1000))));
if (!resource.isNull()) {
content = f_stream_get_contents(resource);
if (!same(content, false)) {
f_apc_store(cache_key, content);
}
}
}
if (!same(content, false)) {
String scontent = content.toString();
xmlDocPtr ret = soap_xmlParseMemory(scontent.data(), scontent.size(), false);
if (ret) {
ret->URL = xmlCharStrdup(filename);
}
return ret;
}
return NULL;
}
bool TestExtApc::test_apc_cas() {
f_apc_store("ts", 12);
f_apc_cas("ts", 12, 15);
VS(f_apc_fetch("ts"), 15);
f_apc_cas("ts", 12, 18);
VS(f_apc_fetch("ts"), 15);
return Count(true);
}
bool TestExtApc::test_apc_delete() {
f_apc_store("ts", "TestString");
f_apc_store("ta", CREATE_MAP2("a", 1, "b", 2));
f_apc_delete("ts");
f_apc_delete("ta");
VS(f_apc_fetch("ts"), false);
VS(f_apc_fetch("ta"), false);
VS(f_apc_fetch("ts"), false);
VS(f_apc_fetch("ta"), false);
f_apc_store("ts", "TestString");
f_apc_store("ta", CREATE_MAP2("a", 1, "b", 2));
VS(f_apc_delete(CREATE_VECTOR2("ts", "ta")), Array::Create());
VS(f_apc_fetch("ts"), false);
VS(f_apc_fetch("ta"), false);
return Count(true);
}
bool TestExtApc::test_apc_store() {
Array complexMap = CREATE_MAP2("a",
CREATE_MAP2("b", 1, "c",
CREATE_VECTOR2("d", "e")),
"f", CREATE_VECTOR3(1,2,3));
f_apc_store("complexMap", complexMap);
f_apc_store("ts", "TestString");
f_apc_store("ta", CREATE_MAP2("a", 1, "b", 2));
f_apc_store("ts", "NewValue");
f_apc_store("ta", CREATE_VECTOR1("newelement"));
VS(f_apc_fetch("ts"), "NewValue");
VS(f_apc_fetch("ta"), CREATE_VECTOR1("newelement"));
VS(f_apc_fetch("complexMap"), complexMap);
VS(f_apc_fetch("ts"), "NewValue");
VS(f_apc_fetch("ta"), CREATE_VECTOR1("newelement"));
VS(f_apc_fetch("complexMap"), complexMap);
// Make sure it doesn't change the shared value.
Array complexMapFetched = f_apc_fetch("complexMap");
VERIFY(complexMapFetched.exists("a"));
complexMapFetched.set("q",0);
VERIFY(complexMapFetched.exists("q"));
VS(f_apc_fetch("complexMap"), complexMap);
String tsFetched = f_apc_fetch("ts");
VS(tsFetched, "NewValue");
String sharedString = tsFetched;
tsFetched.lvalAt(0) = "M";
VS(tsFetched, "MewValue");
VS(sharedString, "NewValue");
VERIFY(tsFetched.get() != sharedString.get());
VS(f_apc_fetch("ts"), "NewValue");
return Count(true);
}
bool TestExtApc::test_apc_add() {
f_apc_add("ts", "TestString");
f_apc_add("ta", CREATE_MAP2("a", 1, "b", 2));
f_apc_add("ts", "NewValue");
f_apc_add("ta", CREATE_VECTOR1("newelement"));
VS(f_apc_fetch("ts"), "TestString");
VS(f_apc_fetch("ta"), CREATE_MAP2("a", 1, "b", 2));
VS(f_apc_fetch("ts"), "TestString");
VS(f_apc_fetch("ta"), CREATE_MAP2("a", 1, "b", 2));
f_apc_add("texp", "TestString", 1);
sleep(1);
VS(f_apc_fetch("texp"), false);
Variant ret = f_apc_store("foo", false);
VS(ret, true);
ret = f_apc_add("foo", false);
VS(ret, false);
Variant success;
ret = f_apc_fetch("foo", ref(success));
VS(ret, false);
VS(success, true);
ret = f_apc_fetch("bar", ref(success));
VS(ret, false);
VS(success, false);
Variant map1= CREATE_MAP1("foo", false);
ret = f_apc_fetch(CREATE_VECTOR1("foo"), ref(success));
VS(ret, map1);
ret = f_apc_fetch(CREATE_VECTOR1("bar"), ref(success));
VS(ret, Array::Create());
VS(success, false);
ret = f_apc_fetch(CREATE_VECTOR2("foo", "bar"), ref(success));
VS(ret, map1);
VS(success, true);
ret = f_apc_fetch(CREATE_VECTOR4("foo", "bar", "foo", "bar"), ref(success));
VS(ret, map1);
VS(success, true);
return Count(true);
}
int apc_rfc1867_progress(apc_rfc1867_data *rfc1867ApcData,
unsigned int event, void *event_data,
void **extra) {
switch (event) {
case MULTIPART_EVENT_START: {
multipart_event_start *data = (multipart_event_start *) event_data;
rfc1867ApcData->content_length = data->content_length;
rfc1867ApcData->tracking_key.clear();
rfc1867ApcData->name.clear();
rfc1867ApcData->cancel_upload = 0;
rfc1867ApcData->temp_filename = NULL;
rfc1867ApcData->start_time = my_time();
rfc1867ApcData->bytes_processed = 0;
rfc1867ApcData->prev_bytes_processed = 0;
rfc1867ApcData->rate = 0;
rfc1867ApcData->update_freq = RuntimeOption::Rfc1867Freq;
if (rfc1867ApcData->update_freq < 0) {
assert(false); // TODO: support percentage
// frequency is a percentage, not bytes
rfc1867ApcData->update_freq =
rfc1867ApcData->content_length * RuntimeOption::Rfc1867Freq / 100;
}
break;
}
case MULTIPART_EVENT_FORMDATA: {
multipart_event_formdata *data = (multipart_event_formdata *)event_data;
if (data->name &&
!strncasecmp(data->name, RuntimeOption::Rfc1867Name.c_str(),
RuntimeOption::Rfc1867Name.size()) &&
data->value && data->length &&
data->length < RFC1867_TRACKING_KEY_MAXLEN -
RuntimeOption::Rfc1867Prefix.size()) {
int len = RuntimeOption::Rfc1867Prefix.size();
if (len > RFC1867_TRACKING_KEY_MAXLEN) {
len = RFC1867_TRACKING_KEY_MAXLEN;
}
rfc1867ApcData->tracking_key =
string(RuntimeOption::Rfc1867Prefix.c_str(), len);
len = strlen(*data->value);
int rem = RFC1867_TRACKING_KEY_MAXLEN -
rfc1867ApcData->tracking_key.size();
if (len > rem) len = rem;
rfc1867ApcData->tracking_key +=
string(*data->value, len);
rfc1867ApcData->bytes_processed = data->post_bytes_processed;
}
/* Facebook: Temporary fix for a bug in PHP's rfc1867 code,
fixed here for convenience:
http://cvs.php.net/viewvc.cgi/php-src/main/
rfc1867.c?r1=1.173.2.1.2.11&r2=1.173.2.1.2.12 */
(*data->newlength) = data->length;
break;
}
case MULTIPART_EVENT_FILE_START:
if (!rfc1867ApcData->tracking_key.empty()) {
multipart_event_file_start *data =
(multipart_event_file_start *)event_data;
rfc1867ApcData->bytes_processed = data->post_bytes_processed;
int len = strlen(*data->filename);
if (len > RFC1867_FILENAME_MAXLEN) len = RFC1867_FILENAME_MAXLEN;
rfc1867ApcData->filename = string(*data->filename, len);
rfc1867ApcData->temp_filename = NULL;
len = strlen(data->name);
if (len > RFC1867_NAME_MAXLEN) len = RFC1867_NAME_MAXLEN;
rfc1867ApcData->name = string(data->name, len);
ArrayInit track(6);
track.set(s_total, rfc1867ApcData->content_length);
track.set(s_current, rfc1867ApcData->bytes_processed);
track.set(s_filename, rfc1867ApcData->filename);
track.set(s_name, rfc1867ApcData->name);
track.set(s_done, 0);
track.set(s_start_time, rfc1867ApcData->start_time);
f_apc_store(rfc1867ApcData->tracking_key, track.create(), 3600);
}
break;
case MULTIPART_EVENT_FILE_DATA:
if (!rfc1867ApcData->tracking_key.empty()) {
multipart_event_file_data *data =
(multipart_event_file_data *) event_data;
rfc1867ApcData->bytes_processed = data->post_bytes_processed;
if (rfc1867ApcData->bytes_processed -
rfc1867ApcData->prev_bytes_processed >
rfc1867ApcData->update_freq) {
Variant v;
if (s_apc_store[0].get(rfc1867ApcData->tracking_key, v)) {
if (v.is(KindOfArray)) {
ArrayInit track(6);
track.set(s_total, rfc1867ApcData->content_length);
track.set(s_current, rfc1867ApcData->bytes_processed);
track.set(s_filename, rfc1867ApcData->filename);
track.set(s_name, rfc1867ApcData->name);
track.set(s_done, 0);
track.set(s_start_time, rfc1867ApcData->start_time);
f_apc_store(rfc1867ApcData->tracking_key, track.create(), 3600);
}
rfc1867ApcData->prev_bytes_processed =
rfc1867ApcData->bytes_processed;
}
}
}
break;
case MULTIPART_EVENT_FILE_END:
if (!rfc1867ApcData->tracking_key.empty()) {
multipart_event_file_end *data =
(multipart_event_file_end *)event_data;
rfc1867ApcData->bytes_processed = data->post_bytes_processed;
rfc1867ApcData->cancel_upload = data->cancel_upload;
rfc1867ApcData->temp_filename = data->temp_filename;
ArrayInit track(8);
track.set(s_total, rfc1867ApcData->content_length);
track.set(s_current, rfc1867ApcData->bytes_processed);
track.set(s_filename, rfc1867ApcData->filename);
track.set(s_name, rfc1867ApcData->name);
track.set(s_temp_filename, rfc1867ApcData->temp_filename, CopyString);
track.set(s_cancel_upload, rfc1867ApcData->cancel_upload);
track.set(s_done, 0);
track.set(s_start_time, rfc1867ApcData->start_time);
f_apc_store(rfc1867ApcData->tracking_key, track.create(), 3600);
}
break;
case MULTIPART_EVENT_END:
if (!rfc1867ApcData->tracking_key.empty()) {
double now = my_time();
multipart_event_end *data = (multipart_event_end *)event_data;
rfc1867ApcData->bytes_processed = data->post_bytes_processed;
if(now>rfc1867ApcData->start_time) {
rfc1867ApcData->rate =
8.0*rfc1867ApcData->bytes_processed/(now-rfc1867ApcData->start_time);
} else {
rfc1867ApcData->rate =
8.0*rfc1867ApcData->bytes_processed; /* Too quick */
ArrayInit track(8);
track.set(s_total, rfc1867ApcData->content_length);
track.set(s_current, rfc1867ApcData->bytes_processed);
track.set(s_rate, rfc1867ApcData->rate);
track.set(s_filename, rfc1867ApcData->filename);
track.set(s_name, rfc1867ApcData->name);
track.set(s_cancel_upload, rfc1867ApcData->cancel_upload);
track.set(s_done, 1);
track.set(s_start_time, rfc1867ApcData->start_time);
f_apc_store(rfc1867ApcData->tracking_key, track.create(), 3600);
}
}
break;
}
return 0;
}
