void requestInit() override {
// This doesn't copy them yet, but will do COW if they are modified
m_GET = php_global(s_GET).toArray();
m_POST = php_global(s_POST).toArray();
m_COOKIE = php_global(s_COOKIE).toArray();
m_SERVER = php_global(s_SERVER).toArray();
m_ENV = php_global(s_ENV).toArray();
}
static Variant HHVM_METHOD(Yaf_Request_Http, getFiles, const Variant& name,
const Variant& def)
{
if (name.isNull()) {
return def;
}
if (!php_global(S_FILES).toArray().exists(name)) {
return def;
}
return php_global(S_FILES).toArray()[name];
}
static bool HHVM_METHOD(Yaf_Request_Http, isXmlHttpRequest)
{
if (!php_global(S_SERVER).toArray().exists(String("HTTP_X_REQUESTED_WITH"))) {
return false;
}
Variant header = php_global(S_SERVER).toArray()[String("HTTP_X_REQUESTED_WITH")];
if (!header.isString()) {
return false;
}
std::string str_header = header.toString().toCppString();
if (strncasecmp(str_header.c_str(), "XMLHttpRequest", str_header.length())) {
return false;
}
return true;
}
std::string& SourceRootInfo::initPhpRoot() {
auto v = php_global(s_SERVER).toArray().rvalAt(s_PHP_ROOT);
if (v.isString()) {
*s_phproot.getCheck() = std::string(v.asCStrRef().data()) + "/";
} else {
// Our best guess at the source root.
*s_phproot.getCheck() = GetCurrentSourceRoot();
}
return *s_phproot.getCheck();
}
std::string& SourceRootInfo::initPhpRoot() {
auto const v = php_global(s_SERVER).toArray().rvalAt(s_PHP_ROOT).unboxed();
if (isStringType(v.type())) {
*s_phproot.getCheck() = std::string(v.val().pstr->data()) + "/";
} else {
// Our best guess at the source root.
*s_phproot.getCheck() = GetCurrentSourceRoot();
}
return *s_phproot.getCheck();
}
static Variant HHVM_METHOD(Yaf_Request_Http, get, const Variant& name,
const Variant& def)
{
if (name.isNull()) {
return def;
}
auto paramsTmp = this_->o_realProp(YAF_REQUEST_PROPERTY_NAME_PARAMS,
ObjectData::RealPropUnchecked, "Yaf_Request_Http");
if (paramsTmp->isNull()) {
return def;
}
Array& params = paramsTmp->toArrRef();
if (params.exists(name)) {
return params[name];
}
if (php_global(S_POST).toArray().exists(name)) {
return php_global(S_POST).toArray()[name];
}
if (php_global(S_GET).toArray().exists(name)) {
return php_global(S_GET).toArray()[name];
}
if (php_global(S_COOKIE).toArray().exists(name)) {
return php_global(S_COOKIE).toArray()[name];
}
if (php_global(S_SERVER).toArray().exists(name)) {
return php_global(S_SERVER).toArray()[name];
}
return def;
}
static Array HHVM_FUNCTION(getopt, const String& options,
const Variant& longopts /*=null */) {
opt_struct *opts, *orig_opts;
int len = parse_opts(options.data(), options.size(), &opts);
if (!longopts.isNull()) {
Array arropts = longopts.toArray();
int count = arropts.size();
/* the first <len> slots are filled by the one short ops
* we now extend our array and jump to the new added structs */
opts = (opt_struct *)smart_realloc(
opts, sizeof(opt_struct) * (len + count + 1));
orig_opts = opts;
opts += len;
memset(opts, 0, count * sizeof(opt_struct));
for (ArrayIter iter(arropts); iter; ++iter) {
String entry = iter.second().toString();
opts->need_param = 0;
opts->opt_name = strdup(entry.data());
len = strlen(opts->opt_name);
if ((len > 0) && (opts->opt_name[len - 1] == ':')) {
opts->need_param++;
opts->opt_name[len - 1] = '\0';
if ((len > 1) && (opts->opt_name[len - 2] == ':')) {
opts->need_param++;
opts->opt_name[len - 2] = '\0';
}
}
opts->opt_char = 0;
opts++;
}
} else {
opts = (opt_struct*) smart_realloc(opts, sizeof(opt_struct) * (len + 1));
orig_opts = opts;
opts += len;
}
/* php_getopt want to identify the last param */
opts->opt_char = '-';
opts->need_param = 0;
opts->opt_name = NULL;
static const StaticString s_argv("argv");
Array vargv = php_global(s_argv).toArray();
int argc = vargv.size();
char **argv = (char **)smart_malloc((argc+1) * sizeof(char*));
std::vector<String> holders;
int index = 0;
for (ArrayIter iter(vargv); iter; ++iter) {
String arg = iter.second().toString();
holders.push_back(arg);
argv[index++] = (char*)arg.data();
}
argv[index] = NULL;
/* after our pointer arithmetic jump back to the first element */
opts = orig_opts;
int o;
char *php_optarg = NULL;
int php_optind = 1;
SCOPE_EXIT {
free_longopts(orig_opts);
smart_free(orig_opts);
smart_free(argv);
};
Array ret = Array::Create();
Variant val;
int optchr = 0;
int dash = 0; /* have already seen the - */
char opt[2] = { '\0' };
char *optname;
int optname_len = 0;
int php_optidx;
while ((o = php_getopt(argc, argv, opts, &php_optarg, &php_optind, 0, 1,
optchr, dash, php_optidx))
!= -1) {
/* Skip unknown arguments. */
if (o == '?') {
continue;
}
/* Prepare the option character and the argument string. */
if (o == 0) {
optname = opts[php_optidx].opt_name;
} else {
if (o == 1) {
o = '-';
}
opt[0] = o;
optname = opt;
}
if (php_optarg != NULL) {
/* keep the arg as binary, since the encoding is not known */
val = String(php_optarg, CopyString);
} else {
val = false;
}
/* Add this option / argument pair to the result hash. */
optname_len = strlen(optname);
if (!(optname_len > 1 && optname[0] == '0') &&
is_numeric_string(optname, optname_len, NULL, NULL, 0) ==
KindOfInt64) {
/* numeric string */
int optname_int = atoi(optname);
if (ret.exists(optname_int)) {
Variant &e = ret.lvalAt(optname_int);
if (!e.isArray()) {
ret.set(optname_int, make_packed_array(e, val));
} else {
e.toArrRef().append(val);
}
} else {
ret.set(optname_int, val);
}
} else {
/* other strings */
String key(optname, strlen(optname), CopyString);
if (ret.exists(key)) {
Variant &e = ret.lvalAt(key);
if (!e.isArray()) {
ret.set(key, make_packed_array(e, val));
} else {
e.toArrRef().append(val);
}
} else {
ret.set(key, val);
}
}
php_optarg = NULL;
}
return ret;
}
Variant yaf_request_http_instance(const Object& object,
const Variant& request_uri, const Variant& var_base_uri)
{
Object o;
if (object.isNull()) {
Array arr = Array::Create();
arr.append(request_uri);
arr.append(var_base_uri);
o = createObject("Yaf_Request_Http", arr) ;
} else {
o = object;
}
const char* base_uri = NULL;
if (var_base_uri.isString() && var_base_uri.toString().length()) {
base_uri = var_base_uri.toString().c_str();
}
auto tmp = o->o_realProp(YAF_REQUEST_PROPERTY_NAME_METHOD,
ObjectData::RealPropUnchecked, "Yaf_Request_Http");
if (php_global(S_SERVER).toArray().exists(String("REQUEST_METHOD"))) {
Variant request_method = php_global(S_SERVER).toArray()[String("REQUEST_METHOD")];
*tmp = request_method;
} else if (strncmp(RuntimeOption::ExecutionMode, "cli", 3) == 0) {
*tmp = String("Cli");
} else {
*tmp = String("Unknown");
}
std::string uri;
if (request_uri.isString()) {
uri = request_uri.toString().toCppString();
} else {
Variant tmp;
if (php_global(S_SERVER).toArray().exists(String("PATH_INFO"))) {
uri = php_global(S_SERVER).toArray()[String("PATH_INFO")].toString().toCppString();
goto done;
}
if (php_global(S_SERVER).toArray().exists(String("REQUEST_URI"))) {
tmp = php_global(S_SERVER).toArray()[String("REQUEST_URI")];
if (tmp.isString()) {
std::string str_tmp = tmp.toString().toCppString();
if (strncasecmp(str_tmp.c_str(), "http", 4) == 0) {
//TODO use php_url_parse to get path
php_url* url_info = php_url_parse(str_tmp.c_str());
if (url_info && url_info->path) {
uri = std::string(url_info->path);
}
php_url_free(url_info);
} else {
const char* tmp_str_tmp = str_tmp.c_str();
const char* pos = strstr(tmp_str_tmp, "?");
if (pos) {
uri = std::string(str_tmp.c_str(), pos - tmp_str_tmp);
} else {
uri = str_tmp;
}
}
}
goto done;
}
if (php_global(S_SERVER).toArray().exists(String("ORIG_PATH_INFO"))) {
uri = php_global(S_SERVER).toArray()[String("ORIG_PATH_INFO")].toString().toCppString();
goto done;
}
}
done:
if (uri.length()) {
const char* p = uri.c_str();
while (*p == '/' && *(p+1) == '/') {
p++;
}
uri = std::string(p);
auto ptr_uri = o->o_realProp(YAF_REQUEST_PROPERTY_NAME_URI,
ObjectData::RealPropUnchecked, "Yaf_Request_Http");
*ptr_uri = String(uri);
yaf_request_set_base_uri(o, base_uri, uri.c_str());
}
auto ptr_params = o->o_realProp(YAF_REQUEST_PROPERTY_NAME_PARAMS,
ObjectData::RealPropUnchecked, "Yaf_Request_Http");
*ptr_params = Array::Create();
return o;
}
