Array f_hphp_get_closure_info(CVarRef closure) {
Array mi = f_hphp_get_method_info(closure.toObject()->o_getClassName(),
s___invoke);
mi.set(s_name, s_closure_in_braces);
mi.set(s_closureobj, closure);
mi.set(s_closure, empty_string);
mi.remove(s_access);
mi.remove(s_modifiers);
mi.remove(s_class);
Array ¶ms = mi.lvalAt(s_params).asArrRef();
for (int i = 0; i < params.size(); i++) {
params.lvalAt(i).asArrRef().remove(s_class);
}
return mi;
}
bool f_property_exists(CVarRef class_or_object, CStrRef property) {
if (class_or_object.isObject()) {
CStrRef context = ctxClassName();
// Call o_exists for objects, to include dynamic properties.
return class_or_object.toObject()->o_propExists(property, context);
}
const ClassInfo *classInfo =
ClassInfo::FindClass(get_classname(class_or_object));
while (classInfo) {
if (classInfo->hasProperty(property)) {
return true;
} else {
classInfo = classInfo->getParentClassInfo();
}
}
return false;
}
Variant f_iterator_apply(CVarRef obj, CVarRef func,
CArrRef params /* = null_array */) {
if (!obj.instanceof("Traversable")) {
return false;
}
Object pobj = obj.toObject();
pobj->o_invoke("rewind", null_array, -1);
int64 count = 0;
while (same(pobj->o_invoke("valid", null_array, -1), true)) {
if (!same(f_call_user_func_array(func, params), true)) {
break;
}
++count;
pobj->o_invoke("next", null_array, -1);
}
return count;
}
Variant f_iterator_to_array(CVarRef obj, bool use_keys /* = true */) {
if (!obj.instanceof("Traversable")) {
return false;
}
Array ret(Array::Create());
Object pobj = obj.toObject();
pobj->o_invoke("rewind", null_array, -1);
while (same(pobj->o_invoke("valid", null_array, -1), true)) {
Variant val = pobj->o_invoke("current", null_array, -1);
if (use_keys) {
Variant key = pobj->o_invoke("key", null_array, -1);
ret.set(key, val);
} else {
ret.append(val);
}
pobj->o_invoke("next", null_array, -1);
}
return ret;
}
Variant f_get_class(CVarRef object /* = null_variant */) {
if (object.isNull()) {
// No arg passed.
String ret;
CallerFrame cf;
Class* cls = arGetContextClassImpl<true>(cf());
if (cls) {
ret = String(cls->nameRef());
}
if (ret.empty()) {
raise_warning("get_class() called without object from outside a class");
return false;
}
return ret;
}
if (!object.isObject()) return false;
return object.toObject()->o_getClassName();
}
Variant f_class_uses(CVarRef obj, bool autoload /* = true */) {
String clsname;
if (obj.isString()) {
clsname = obj.toString();
} else if (obj.isObject()) {
clsname = obj.toObject()->o_getClassName();
} else {
return false;
}
const ClassInfo *info = ClassInfo::FindClassInterfaceOrTrait(clsname);
if (!info) {
return false;
}
Array ret(Array::Create());
const ClassInfo::TraitVec &traits = info->getTraitsVec();
for (unsigned int i = 0; i < traits.size(); i++) {
ret.set(traits[i], traits[i]);
}
return ret;
}
Object get_traversable_object_iterator(CVarRef obj) {
if (!obj.instanceof(SystemLib::s_TraversableClass)) {
raise_error("Argument must implement interface Traversable");
}
bool isIteratorAggregate;
Object itObj = obj.getObjectData()
->iterableObject(isIteratorAggregate, true);
if (!isIteratorAggregate) {
if (obj.instanceof(SystemLib::s_IteratorAggregateClass)) {
raise_error("Objects returned by getIterator() must be traversable or "
"implement interface Iterator");
} else {
raise_error(
"Class %s must implement interface Traversable as part of either "
"Iterator or IteratorAggregate",
obj.toObject()->o_getClassName()->data()
);
}
}
return itObj;
}
int64_t f_count(CVarRef var, bool recursive /* = false */) {
switch (var.getType()) {
case KindOfUninit:
case KindOfNull:
return 0;
case KindOfObject:
{
Object obj = var.toObject();
if (obj.instanceof(SystemLib::s_CountableClass)) {
return obj->o_invoke("count", null_array, -1);
}
}
break;
case KindOfArray:
if (recursive) {
CArrRef arr_var = var.toCArrRef();
return php_count_recursive(arr_var);
}
return var.getArrayData()->size();
default:
break;
}
return 1;
}
Variant f_class_parents(CVarRef obj, bool autoload /* = true */) {
String clsname;
if (obj.isString()) {
clsname = obj.toString();
} else if (obj.isObject()) {
clsname = obj.toObject()->o_getClassName();
} else {
return false;
}
const ClassInfo *info = ClassInfo::FindClass(clsname);
if (info == NULL) {
return false;
}
Array ret(Array::Create());
ClassInfo::ClassVec parents;
info->getAllParentsVec(parents);
for (unsigned int i = 0; i < parents.size(); i++) {
ret.set(parents[i], parents[i]);
}
return ret;
}
Variant f_class_implements(CVarRef obj, bool autoload /* = true */) {
String clsname;
if (obj.isString()) {
clsname = obj.toString();
} else if (obj.isObject()) {
clsname = obj.toObject()->o_getClassName();
} else {
return false;
}
const ClassInfo *info = ClassInfo::FindClassInterfaceOrTrait(clsname);
if (info == NULL) {
return false;
}
Array ret(Array::Create());
ClassInfo::InterfaceVec ifs;
info->getAllInterfacesVec(ifs);
for (unsigned int i = 0; i < ifs.size(); i++) {
ret.set(ifs[i], ifs[i]);
}
return ret;
}
Variant f_get_class(CVarRef object /* = null_variant */) {
if (!object.isObject()) return false;
return object.toObject()->o_getClassName();
}
Array f_hphp_get_class_info(CVarRef name) {
String className;
if (name.isObject()) {
className = name.toObject()->o_getClassName();
} else {
className = name.toString();
}
const ClassInfo *cls = ClassInfo::FindClass(className.data());
if (cls == NULL) {
cls = ClassInfo::FindInterface(className.data());
}
Array ret;
if (cls == NULL) {
return ret;
}
ret.set("name", cls->getName());
ret.set("extension", "");
ret.set("parent", cls->getParentClass());
// interfaces
{
Array arr = Array::Create();
const ClassInfo::InterfaceMap &interfaces = cls->getInterfaces();
for (ClassInfo::InterfaceMap::const_iterator iter = interfaces.begin();
iter != interfaces.end(); ++iter) {
arr.set(*iter, 1);
}
ret.set("interfaces", arr);
}
// attributes
{
int attribute = cls->getAttribute();
ret.set("internal", (bool)(attribute & ClassInfo::IsSystem));
ret.set("abstract", (bool)(attribute & ClassInfo::IsAbstract));
ret.set("interface", (bool)(attribute & ClassInfo::IsInterface));
ret.set("final", (bool)(attribute & ClassInfo::IsFinal));
ret.set("modifiers", get_modifiers(attribute, true));
}
// methods
{
Array arr = Array::Create();
const ClassInfo::MethodVec &methods = cls->getMethodsVec();
for (ClassInfo::MethodVec::const_iterator iter = methods.begin();
iter != methods.end(); ++iter) {
ClassInfo::MethodInfo *m = *iter;
if ((m->attribute & ClassInfo::IsInherited) == 0) {
Array info = Array::Create();
set_method_info(info, m, cls);
arr.set(StringUtil::ToLower(m->name), info);
}
}
ret.set("methods", arr);
}
// properties
{
Array arr = Array::Create();
const ClassInfo::PropertyMap &properties = cls->getProperties();
for (ClassInfo::PropertyMap::const_iterator iter = properties.begin();
iter != properties.end(); ++iter) {
Array info = Array::Create();
set_property_info(info, iter->second, cls);
arr.set(iter->first, info);
}
ret.set("properties", arr);
}
// constants
{
Array arr = Array::Create();
const ClassInfo::ConstantMap &constants = cls->getConstants();
for (ClassInfo::ConstantMap::const_iterator iter = constants.begin();
iter != constants.end(); ++iter) {
if (iter->second->valueText && *iter->second->valueText) {
arr.set(iter->second->name, iter->second->value);
} else {
arr.set(iter->second->name,
get_class_constant(className.data(), iter->second->name));
}
}
ret.set("constants", arr);
}
{ // source info
const char *file =
SourceInfo::TheSourceInfo.getClassDeclaringFile(className.data());
if (!file) file = "";
if (file[0] != '/') {
ret.set("file", String(RuntimeOption::SourceRoot + file));
} else {
ret.set("file", file);
}
ret.set("line1", 0);
ret.set("line2", 0);
const char *dc = cls->getDocComment();
if (dc) {
ret.set("doc", dc);
} else {
ret.set("doc", false);
}
}
return ret;
}
void binary_serialize(int8_t thrift_typeID, PHPOutputTransport& transport,
CVarRef value, CArrRef fieldspec) {
// At this point the typeID (and field num, if applicable) should've already
// been written to the output so all we need to do is write the payload.
switch (thrift_typeID) {
case T_STOP:
case T_VOID:
return;
case T_STRUCT: {
if (!value.is(KindOfObject)) {
throw_tprotocolexception("Attempt to send non-object "
"type as a T_STRUCT", INVALID_DATA);
}
binary_serialize_spec(value.toObject(), transport,
f_hphp_get_static_property(value.toObject()->
o_getClassName(),
s_TSPEC,
false).toArray());
} return;
case T_BOOL:
transport.writeI8(value.toBoolean() ? 1 : 0);
return;
case T_BYTE:
transport.writeI8(value.toByte());
return;
case T_I16:
transport.writeI16(value.toInt16());
return;
case T_I32:
transport.writeI32(value.toInt32());
return;
case T_I64:
case T_U64:
transport.writeI64(value.toInt64());
return;
case T_DOUBLE: {
union {
int64_t c;
double d;
} a;
a.d = value.toDouble();
transport.writeI64(a.c);
} return;
case T_FLOAT: {
union {
int32_t c;
float d;
} a;
a.d = (float)value.toDouble();
transport.writeI32(a.c);
} return;
//case T_UTF7:
case T_UTF8:
case T_UTF16:
case T_STRING: {
String sv = value.toString();
transport.writeString(sv.data(), sv.size());
} return;
case T_MAP: {
Array ht = value.toArray();
uint8_t keytype = fieldspec.rvalAt(PHPTransport::s_ktype,
AccessFlags::Error_Key).toByte();
transport.writeI8(keytype);
uint8_t valtype = fieldspec.rvalAt(PHPTransport::s_vtype,
AccessFlags::Error_Key).toByte();
transport.writeI8(valtype);
Array valspec = fieldspec.rvalAt(PHPTransport::s_val,
AccessFlags::Error_Key).toArray();
transport.writeI32(ht.size());
for (ArrayIter key_ptr = ht.begin(); !key_ptr.end(); ++key_ptr) {
binary_serialize_hashtable_key(keytype, transport, key_ptr.first());
binary_serialize(valtype, transport, key_ptr.second(), valspec);
}
} return;
case T_LIST: {
Array ht = value.toArray();
Variant val;
uint8_t valtype = fieldspec.rvalAt(PHPTransport::s_etype,
AccessFlags::Error_Key).toInt64();
transport.writeI8(valtype);
Array valspec = fieldspec.rvalAt(PHPTransport::s_elem,
AccessFlags::Error_Key).toArray();
transport.writeI32(ht.size());
for (ArrayIter key_ptr = ht.begin(); !key_ptr.end(); ++key_ptr) {
binary_serialize(valtype, transport, key_ptr.second(), valspec);
}
} return;
case T_SET: {
Array ht = value.toArray();
uint8_t keytype = fieldspec.rvalAt(PHPTransport::s_etype,
AccessFlags::Error_Key).toByte();
transport.writeI8(keytype);
transport.writeI32(ht.size());
for (ArrayIter key_ptr = ht.begin(); !key_ptr.end(); ++key_ptr) {
binary_serialize_hashtable_key(keytype, transport, key_ptr.first());
}
} return;
};
char errbuf[128];
sprintf(errbuf, "Unknown thrift typeID %d", thrift_typeID);
throw_tprotocolexception(String(errbuf, CopyString), INVALID_DATA);
}
Array f_hphp_get_class_info(CVarRef name) {
String className;
if (name.isObject()) {
className = name.toObject()->o_getClassName();
} else {
className = name.toString();
}
const ClassInfo *cls = ClassInfo::FindClass(className);
if (cls == NULL) {
cls = ClassInfo::FindInterface(className);
}
if (cls == NULL) {
cls = ClassInfo::FindTrait(className);
}
Array ret;
if (cls == NULL) {
return ret;
}
ret.set("name", cls->getName());
ret.set("extension", "");
ret.set("parent", cls->getParentClass());
// interfaces
{
Array arr = Array::Create();
const ClassInfo::InterfaceVec &interfaces = cls->getInterfacesVec();
for (ClassInfo::InterfaceVec::const_iterator iter = interfaces.begin();
iter != interfaces.end(); ++iter) {
arr.set(*iter, 1);
}
ret.set("interfaces", arr);
}
// traits
{
Array arr = Array::Create();
const ClassInfo::TraitVec &traits = cls->getTraitsVec();
for (ClassInfo::TraitVec::const_iterator iter = traits.begin();
iter != traits.end(); ++iter) {
arr.set(*iter, 1);
}
ret.set("traits", arr);
}
// trait aliases
{
Array arr = Array::Create();
const ClassInfo::TraitAliasVec &aliases = cls->getTraitAliasesVec();
for (ClassInfo::TraitAliasVec::const_iterator iter = aliases.begin();
iter != aliases.end(); ++iter) {
arr.set(iter->first, iter->second);
}
ret.set("trait_aliases", arr);
}
// attributes
{
int attribute = cls->getAttribute();
ret.set("internal", (bool)(attribute & ClassInfo::IsSystem));
ret.set("hphp", (bool)(attribute & ClassInfo::HipHopSpecific));
ret.set("abstract", (bool)(attribute & ClassInfo::IsAbstract));
ret.set("interface", (bool)(attribute & ClassInfo::IsInterface));
ret.set("final", (bool)(attribute & ClassInfo::IsFinal));
ret.set("trait", (bool)(attribute & ClassInfo::IsTrait));
ret.set("modifiers", get_modifiers(attribute, true));
}
// methods
{
Array arr = Array::Create();
const ClassInfo::MethodVec &methods = cls->getMethodsVec();
for (ClassInfo::MethodVec::const_iterator iter = methods.begin();
iter != methods.end(); ++iter) {
ClassInfo::MethodInfo *m = *iter;
if ((m->attribute & ClassInfo::IsInherited) == 0) {
Array info = Array::Create();
set_method_info(info, m, cls);
arr.set(StringUtil::ToLower(m->name), info);
}
}
ret.set("methods", arr);
}
// properties
{
Array arr = Array::Create();
const ClassInfo::PropertyVec &properties = cls->getPropertiesVec();
for (ClassInfo::PropertyVec::const_iterator iter = properties.begin();
iter != properties.end(); ++iter) {
ClassInfo::PropertyInfo *prop = *iter;
Array info = Array::Create();
set_property_info(info, prop, cls);
arr.set(prop->name, info);
}
ret.set("properties", arr);
}
// constants
{
Array arr = Array::Create();
const ClassInfo::ConstantVec &constants = cls->getConstantsVec();
for (ClassInfo::ConstantVec::const_iterator iter = constants.begin();
iter != constants.end(); ++iter) {
ClassInfo::ConstantInfo *info = *iter;
if (info->valueText && *info->valueText) {
arr.set(info->name, info->getValue());
} else {
arr.set(info->name, get_class_constant(className, info->name));
}
}
ret.set("constants", arr);
}
{ // source info
if (!set_source_info(ret, cls->getFile(), cls->getLine1(),
cls->getLine2())) {
int line = 0;
const char *file = SourceInfo::TheSourceInfo.
getClassDeclaringFile(className, &line);
set_source_info(ret, file, line, line);
}
set_doc_comment(ret, cls->getDocComment());
}
return ret;
}
Object f_hphp_splfileobject___construct(CObjRef obj, CStrRef filename, CStrRef open_mode, bool use_include_path, CVarRef context) {
Variant f = f_fopen(filename, open_mode, use_include_path,
context.isNull() ? null_object : context.toObject());
obj->o_set("rsrc", NEWOBJ(SplFileObject)(f), "SplFileInfo");
return obj;
}
Variant f_get_object_vars(CVarRef object) {
if (object.isObject()) {
return object.toObject()->o_toIterArray(FrameInjection::GetClassName(true));
}
return false;
}
bool setOption(long option, CVarRef value) {
if (m_cp == NULL) {
return false;
}
m_error_no = CURLE_OK;
switch (option) {
case CURLOPT_INFILESIZE:
case CURLOPT_VERBOSE:
case CURLOPT_HEADER:
case CURLOPT_NOPROGRESS:
case CURLOPT_NOBODY:
case CURLOPT_FAILONERROR:
case CURLOPT_UPLOAD:
case CURLOPT_POST:
case CURLOPT_FTPLISTONLY:
case CURLOPT_FTPAPPEND:
case CURLOPT_NETRC:
case CURLOPT_PUT:
case CURLOPT_TIMEOUT:
#if LIBCURL_VERSION_NUM >= 0x071002
case CURLOPT_TIMEOUT_MS:
#endif
case CURLOPT_FTP_USE_EPSV:
case CURLOPT_LOW_SPEED_LIMIT:
case CURLOPT_SSLVERSION:
case CURLOPT_LOW_SPEED_TIME:
case CURLOPT_RESUME_FROM:
case CURLOPT_TIMEVALUE:
case CURLOPT_TIMECONDITION:
case CURLOPT_TRANSFERTEXT:
case CURLOPT_HTTPPROXYTUNNEL:
case CURLOPT_FILETIME:
case CURLOPT_MAXREDIRS:
case CURLOPT_MAXCONNECTS:
case CURLOPT_CLOSEPOLICY:
case CURLOPT_FRESH_CONNECT:
case CURLOPT_FORBID_REUSE:
case CURLOPT_CONNECTTIMEOUT:
#if LIBCURL_VERSION_NUM >= 0x071002
case CURLOPT_CONNECTTIMEOUT_MS:
#endif
case CURLOPT_SSL_VERIFYHOST:
case CURLOPT_SSL_VERIFYPEER:
//case CURLOPT_DNS_USE_GLOBAL_CACHE: not thread-safe when set to true
case CURLOPT_NOSIGNAL:
case CURLOPT_PROXYTYPE:
case CURLOPT_BUFFERSIZE:
case CURLOPT_HTTPGET:
case CURLOPT_HTTP_VERSION:
case CURLOPT_CRLF:
case CURLOPT_DNS_CACHE_TIMEOUT:
case CURLOPT_PROXYPORT:
case CURLOPT_FTP_USE_EPRT:
case CURLOPT_HTTPAUTH:
case CURLOPT_PROXYAUTH:
case CURLOPT_FTP_CREATE_MISSING_DIRS:
case CURLOPT_FTPSSLAUTH:
case CURLOPT_FTP_SSL:
case CURLOPT_UNRESTRICTED_AUTH:
case CURLOPT_PORT:
case CURLOPT_AUTOREFERER:
case CURLOPT_COOKIESESSION:
case CURLOPT_TCP_NODELAY:
case CURLOPT_IPRESOLVE:
case CURLOPT_FOLLOWLOCATION:
m_error_no = curl_easy_setopt(m_cp, (CURLoption)option, value.toInt64());
break;
case CURLOPT_RETURNTRANSFER:
m_write.method = value.toBoolean() ? PHP_CURL_RETURN : PHP_CURL_STDOUT;
break;
case CURLOPT_BINARYTRANSFER:
m_write.type = value.toBoolean() ? PHP_CURL_BINARY : PHP_CURL_ASCII;
break;
case CURLOPT_PRIVATE:
case CURLOPT_URL:
case CURLOPT_PROXY:
case CURLOPT_USERPWD:
case CURLOPT_PROXYUSERPWD:
case CURLOPT_RANGE:
case CURLOPT_CUSTOMREQUEST:
case CURLOPT_USERAGENT:
case CURLOPT_FTPPORT:
case CURLOPT_COOKIE:
case CURLOPT_REFERER:
case CURLOPT_INTERFACE:
case CURLOPT_KRB4LEVEL:
case CURLOPT_EGDSOCKET:
case CURLOPT_CAINFO:
case CURLOPT_CAPATH:
case CURLOPT_SSL_CIPHER_LIST:
case CURLOPT_SSLKEY:
case CURLOPT_SSLKEYTYPE:
case CURLOPT_SSLKEYPASSWD:
case CURLOPT_SSLENGINE:
case CURLOPT_SSLENGINE_DEFAULT:
case CURLOPT_SSLCERTTYPE:
case CURLOPT_ENCODING:
case CURLOPT_COOKIEJAR:
case CURLOPT_SSLCERT:
case CURLOPT_RANDOM_FILE:
case CURLOPT_COOKIEFILE:
{
String svalue = value.toString();
#if LIBCURL_VERSION_NUM >= 0x071100
/* Strings passed to libcurl as 'char *' arguments, are copied
by the library... NOTE: before 7.17.0 strings were not copied. */
m_error_no = curl_easy_setopt(m_cp, (CURLoption)option, svalue.c_str());
#else
char *copystr = strndup(svalue.data(), svalue.size());
m_to_free->str.push_back(copystr);
m_error_no = curl_easy_setopt(m_cp, (CURLoption)option, copystr);
#endif
if (option == CURLOPT_URL) m_url = value;
}
break;
case CURLOPT_FILE:
case CURLOPT_INFILE:
case CURLOPT_WRITEHEADER:
case CURLOPT_STDERR:
{
if (!value.is(KindOfObject)) {
return false;
}
Object obj = value.toObject();
if (obj.isNull() || obj.getTyped<File>(true) == NULL) {
return false;
}
switch (option) {
case CURLOPT_FILE:
m_write.fp = obj;
m_write.method = PHP_CURL_FILE;
break;
case CURLOPT_WRITEHEADER:
m_write_header.fp = obj;
m_write_header.method = PHP_CURL_FILE;
break;
case CURLOPT_INFILE:
m_read.fp = obj;
m_emptyPost = false;
break;
default: {
if (obj.getTyped<PlainFile>(true) == NULL) {
return false;
}
FILE *fp = obj.getTyped<PlainFile>()->getStream();
if (!fp) {
return false;
}
m_error_no = curl_easy_setopt(m_cp, (CURLoption)option, fp);
break;
}
}
}
break;
case CURLOPT_WRITEFUNCTION:
m_write.callback = value;
m_write.method = PHP_CURL_USER;
break;
case CURLOPT_READFUNCTION:
m_read.callback = value;
m_read.method = PHP_CURL_USER;
m_emptyPost = false;
break;
case CURLOPT_HEADERFUNCTION:
m_write_header.callback = value;
m_write_header.method = PHP_CURL_USER;
break;
case CURLOPT_POSTFIELDS:
m_emptyPost = false;
if (value.is(KindOfArray) || value.is(KindOfObject)) {
Array arr = value.toArray();
curl_httppost *first = NULL;
curl_httppost *last = NULL;
for (ArrayIter iter(arr); iter; ++iter) {
String key = iter.first().toString();
String val = iter.second().toString();
const char *postval = val.data();
/* The arguments after _NAMELENGTH and _CONTENTSLENGTH
* must be explicitly cast to long in curl_formadd
* use since curl needs a long not an int. */
if (*postval == '@') {
++postval;
m_error_no = (CURLcode)curl_formadd
(&first, &last,
CURLFORM_COPYNAME, key.data(),
CURLFORM_NAMELENGTH, (long)key.size(),
CURLFORM_FILE, postval,
CURLFORM_END);
} else {
m_error_no = (CURLcode)curl_formadd
(&first, &last,
CURLFORM_COPYNAME, key.data(),
CURLFORM_NAMELENGTH, (long)key.size(),
CURLFORM_COPYCONTENTS, postval,
CURLFORM_CONTENTSLENGTH,(long)val.size(),
CURLFORM_END);
}
}
if (m_error_no != CURLE_OK) {
return false;
}
m_to_free->post.push_back(first);
m_error_no = curl_easy_setopt(m_cp, CURLOPT_HTTPPOST, first);
} else {
String svalue = value.toString();
#if LIBCURL_VERSION_NUM >= 0x071100
/* with curl 7.17.0 and later, we can use COPYPOSTFIELDS,
but we have to provide size before */
m_error_no = curl_easy_setopt(m_cp, CURLOPT_POSTFIELDSIZE,
svalue.size());
m_error_no = curl_easy_setopt(m_cp, CURLOPT_COPYPOSTFIELDS,
svalue.c_str());
#else
char *post = strndup(svalue.data(), svalue.size());
m_to_free->str.push_back(post);
m_error_no = curl_easy_setopt(m_cp, CURLOPT_POSTFIELDS, post);
m_error_no = curl_easy_setopt(m_cp, CURLOPT_POSTFIELDSIZE,
svalue.size());
#endif
}
break;
case CURLOPT_HTTPHEADER:
case CURLOPT_QUOTE:
case CURLOPT_HTTP200ALIASES:
case CURLOPT_POSTQUOTE:
if (value.is(KindOfArray) || value.is(KindOfObject)) {
Array arr = value.toArray();
curl_slist *slist = NULL;
for (ArrayIter iter(arr); iter; ++iter) {
String key = iter.first().toString();
String val = iter.second().toString();
slist = curl_slist_append(slist, val.c_str());
if (!slist) {
raise_warning("Could not build curl_slist");
return false;
}
}
m_to_free->slist.push_back(slist);
m_error_no = curl_easy_setopt(m_cp, (CURLoption)option, slist);
} else {
raise_warning("You must pass either an object or an array with "
"the CURLOPT_HTTPHEADER, CURLOPT_QUOTE, "
"CURLOPT_HTTP200ALIASES and CURLOPT_POSTQUOTE "
"arguments");
return false;
}
break;
case CURLINFO_HEADER_OUT:
if (value.toInt64() == 1) {
curl_easy_setopt(m_cp, CURLOPT_DEBUGFUNCTION, curl_debug);
curl_easy_setopt(m_cp, CURLOPT_DEBUGDATA, (void *)this);
curl_easy_setopt(m_cp, CURLOPT_VERBOSE, 1);
} else {
curl_easy_setopt(m_cp, CURLOPT_DEBUGFUNCTION, NULL);
curl_easy_setopt(m_cp, CURLOPT_DEBUGDATA, NULL);
curl_easy_setopt(m_cp, CURLOPT_VERBOSE, 0);
}
break;
default:
m_error_no = CURLE_FAILED_INIT;
throw_invalid_argument("option: %d", option);
break;
}
m_opts.set(int64(option), value);
return m_error_no == CURLE_OK;
}
static void url_encode_array(StringBuffer &ret, CVarRef varr,
std::set<void*> &seen_arrs,
const String& num_prefix, const String& key_prefix,
const String& key_suffix, const String& arg_sep) {
void *id = varr.is(KindOfArray) ?
(void*)varr.getArrayData() : (void*)varr.getObjectData();
if (!seen_arrs.insert(id).second) {
return; // recursive
}
Array arr;
if (varr.is(KindOfObject)) {
Object o = varr.toObject();
arr = (o.objectForCall()->isCollection()) ?
varr.toArray() :
f_get_object_vars(o).toArray();
} else {
arr = varr.toArray();
}
for (ArrayIter iter(arr); iter; ++iter) {
Variant data = iter.second();
if (data.isNull() || data.isResource()) continue;
String key = iter.first();
bool numeric = key.isNumeric();
if (data.is(KindOfArray) || data.is(KindOfObject)) {
String encoded;
if (numeric) {
encoded = key;
} else {
encoded = StringUtil::UrlEncode(key);
}
StringBuffer new_prefix(key_prefix.size() + num_prefix.size() +
encoded.size() + key_suffix.size() + 4);
new_prefix.append(key_prefix);
if (numeric) new_prefix.append(num_prefix);
new_prefix.append(encoded);
new_prefix.append(key_suffix);
new_prefix.append("%5B");
url_encode_array(ret, data, seen_arrs, String(),
new_prefix.detach(), String("%5D", CopyString),
arg_sep);
} else {
if (!ret.empty()) {
ret.append(arg_sep);
}
ret.append(key_prefix);
if (numeric) {
ret.append(num_prefix);
ret.append(key);
} else {
ret.append(StringUtil::UrlEncode(key));
}
ret.append(key_suffix);
ret.append("=");
if (data.isInteger() || data.is(KindOfBoolean)) {
ret.append(String(data.toInt64()));
} else if (data.is(KindOfDouble)) {
ret.append(String(data.toDouble()));
} else {
ret.append(StringUtil::UrlEncode(data.toString()));
}
}
}
}