/*
* Print info about variable: php var_dump()
*/
void php_var_dump(PHP_VALUE_NODE *node, int ident, int ref)
{
for(int i = 0; i < ident;i++) {
printf("\t");
}
if ( ref ) printf("&");
switch(node->type) {
case PHP_VAL_BOOL: printf("bool(%s)\n", node->int_val ? "true" : "false"); break;
case PHP_VAL_INT: printf("int(%"PRIu64")\n", node->int_val); break;
case PHP_VAL_FLOAT: printf("float(%f)\n", node->float_val); break;
case PHP_VAL_STRING: printf("string(%d) \"%s\"\n", (int)strlen(node->str_val), node->str_val); break;
case PHP_VAL_OBJECT: printf("Object(%s)\n", node->obj_val.class_name); break;
case PHP_VAL_ARRAY: {
int arr_size = array_get_size(node);
printf("array(%d) {\n", arr_size);
for(int i = 0; i < arr_size;i++) {
const std::string &curr_key = array_get_ith_key(node, i);
PHP_VAR_NODE *curr_val = array_get_by_str_key(node, curr_key);
printf("\t[%s]=>\n", curr_key.c_str());
php_var_dump(&curr_val->value, ident+1, curr_val->ref_count > 1);
}
for(int i = 0; i < ident;i++) {
printf("\t");
}
printf("}\n");
break;
}
case PHP_VAL_NONE: printf("NULL\n"); break;
case PHP_VAL_VAR_NODE:
case PHP_VAL_INT_DATA: assert(0); break;
}
}
/*
* Return hash of amule options.
* Key: option name
* Value: option value (string)
*/
void php_get_amule_options(PHP_VALUE_NODE *result)
{
cast_value_array(result);
CECPacket req(EC_OP_GET_PREFERENCES);
req.AddTag(CECTag(EC_TAG_SELECT_PREFS, (uint32)0xffffffff));
const CECPacket *reply = CPhPLibContext::g_curr_context->WebServer()->webInterface->SendRecvMsg_v2(&req);
if ( !reply || !reply->HasChildTags()) {
return ;
}
const CECTag *cattag = 0;
PHP_VALUE_NODE intval;
intval.type = PHP_VAL_INT;
if ((cattag = reply->GetTagByName(EC_TAG_PREFS_GENERAL)) != 0) {
PHP_VAR_NODE *key = array_get_by_str_key(result, "nick");
value_value_free(&key->value);
key->value.type = PHP_VAL_STRING;
key->value.str_val = strdup(unicode2UTF8(cattag->GetTagByNameSafe(EC_TAG_USER_NICK)->GetStringData()));
}
if ((cattag = reply->GetTagByName(EC_TAG_PREFS_CONNECTIONS)) != 0) {
PHP_VAR_NODE *cat = array_get_by_str_key(result, "connection");
cast_value_array(&cat->value);
ec_tag_2_php(cattag, g_connection_opt_defs, cat);
}
if ((cattag = reply->GetTagByName(EC_TAG_PREFS_FILES)) != 0) {
PHP_VAR_NODE *cat = array_get_by_str_key(result, "files");
cast_value_array(&cat->value);
ec_tag_2_php(cattag, g_file_opt_defs, cat);
}
if ((cattag = reply->GetTagByName(EC_TAG_PREFS_REMOTECTRL)) != 0) {
PHP_VAR_NODE *cat = array_get_by_str_key(result, "webserver");
cast_value_array(&cat->value);
ec_tag_2_php(cattag, g_webserver_opt_defs, cat);
}
if ((cattag = reply->GetTagByName(EC_TAG_PREFS_CORETWEAKS)) != 0) {
PHP_VAR_NODE *cat = array_get_by_str_key(result, "coretweaks");
cast_value_array(&cat->value);
ec_tag_2_php(cattag, g_coretweak_opt_defs, cat);
}
}
void set_array_int_val(PHP_VALUE_NODE *array, std::string arrkey, int value)
{
PHP_VAR_NODE *key = array_get_by_str_key(array, arrkey);
PHP_VALUE_NODE intval;
intval.type = PHP_VAL_INT;
intval.int_val = value;
value_value_assign(&key->value, &intval);
}
/*
* Set amule options from given array. Argument looks like "amule_get_options" result
*/
void php_set_amule_options(PHP_VALUE_NODE *)
{
PHP_SCOPE_ITEM *si = get_scope_item(g_current_scope, "__param_0");
if ( !si || (si->var->value.type != PHP_VAL_ARRAY)) {
php_report_error(PHP_ERROR, "Invalid or missing argument 1 (options array)");
return;
}
CECPacket req(EC_OP_SET_PREFERENCES);
PHP_VAR_NODE *opt_group_array = 0;
// files
opt_group_array = array_get_by_str_key(&si->var->value, "files");
if ( opt_group_array->value.type == PHP_VAL_ARRAY ) {
CECEmptyTag filePrefs(EC_TAG_PREFS_FILES);
php_2_ec_tag(&filePrefs, g_file_opt_defs, &opt_group_array->value);
req.AddTag(filePrefs);
}
// connection
opt_group_array = array_get_by_str_key(&si->var->value, "connection");
if ( opt_group_array->value.type == PHP_VAL_ARRAY ) {
CECEmptyTag connPrefs(EC_TAG_PREFS_CONNECTIONS);
php_2_ec_tag(&connPrefs, g_connection_opt_defs, &opt_group_array->value);
req.AddTag(connPrefs);
}
// webserver
opt_group_array = array_get_by_str_key(&si->var->value, "webserver");
if ( opt_group_array->value.type == PHP_VAL_ARRAY ) {
CECEmptyTag webPrefs(EC_TAG_PREFS_REMOTECTRL);
php_2_ec_tag(&webPrefs, g_webserver_opt_defs, &opt_group_array->value);
req.AddTag(webPrefs);
// also apply settings localy
PHP_VAR_NODE *pref = array_get_by_str_key(&opt_group_array->value, "use_gzip");
cast_value_dnum(&pref->value);
CPhPLibContext::g_curr_context->WebServer()->webInterface->m_UseGzip = pref->value.int_val != 0;
pref = array_get_by_str_key(&opt_group_array->value, "autorefresh_time");
cast_value_dnum(&pref->value);
CPhPLibContext::g_curr_context->WebServer()->webInterface->m_PageRefresh = pref->value.int_val;
}
CPhPLibContext::g_curr_context->WebServer()->Send_Discard_V2_Request(&req);
}
/*
* Convert CEC_StatTree_Node_Tag into php associative array
*
* Since data structure is recoursive - we need helper function
* to perform conversion
*/
void ecstats2php(CEC_StatTree_Node_Tag *root, PHP_VALUE_NODE *result)
{
cast_value_array(result);
std::string key(unicode2UTF8(root->GetDisplayString()));
PHP_VAR_NODE *v_key = array_get_by_str_key(result, key);
for (CECTag::const_iterator it = root->begin(); it != root->end(); it++) {
CEC_StatTree_Node_Tag *tag = (CEC_StatTree_Node_Tag*) & *it;
if (tag->GetTagName() == EC_TAG_STATTREE_NODE) {
ecstats2php(tag, &v_key->value);
}
}
}
void load_session_vars(const char *target, std::map<std::string, std::string> &varmap)
{
PHP_EXP_NODE *sess_vars_exp_node = get_var_node(target);
PHP_VAR_NODE *sess_vars = sess_vars_exp_node->var_si_node->var;
// i'm not building exp tree, node not needed
delete sess_vars_exp_node;
cast_value_array(&sess_vars->value);
for(std::map<std::string, std::string>::iterator i = varmap.begin(); i != varmap.end(); i++) {
PHP_VAR_NODE *curr_var = array_get_by_str_key(&sess_vars->value, i->first);
PHP_VALUE_NODE val;
val.type = PHP_VAL_STRING;
val.str_val = const_cast<char *>(i->second.c_str());
value_value_assign(&curr_var->value, &val);
}
}
void save_session_vars(std::map<std::string, std::string> &varmap)
{
PHP_EXP_NODE *sess_vars_exp_node = get_var_node("_SESSION");
PHP_VAR_NODE *sess_vars = sess_vars_exp_node->var_si_node->var;
delete sess_vars_exp_node;
if ( sess_vars->value.type != PHP_VAL_ARRAY ) {
return;
}
for(int i = 0; i < array_get_size(&sess_vars->value); i++) {
std::string s = array_get_ith_key(&sess_vars->value, i);
PHP_VAR_NODE *var = array_get_by_str_key(&sess_vars->value, s);
cast_value_str(&var->value);
varmap[s] = var->value.str_val;
}
}
bool php_2_ec_tag(CECTag *cattag, PHP_2_EC_OPT_DEF *opts, PHP_VALUE_NODE *catvar)
{
for(PHP_2_EC_OPT_DEF *def = opts; def->php_name; def++) {
PHP_VAR_NODE *opt_var = array_get_by_str_key(catvar, def->php_name);
if ( opt_var->value.type == PHP_VAL_NONE ) {
continue;
}
cast_value_dnum(&opt_var->value);
switch(def->opsize) {
case 0: // always transmit !
case 1: cattag->AddTag(CECTag(def->tagname ,(uint8)opt_var->value.int_val)); break;
case 2: cattag->AddTag(CECTag(def->tagname ,(uint16)opt_var->value.int_val)); break;
case 4: cattag->AddTag(CECTag(def->tagname ,(uint32)opt_var->value.int_val)); break;
default: return false;
}
}
return true;
}
/*
* Query amule status. Return hash containing stats values
*/
void php_get_amule_stats(PHP_VALUE_NODE *result)
{
CECPacket stat_req(EC_OP_STAT_REQ, EC_DETAIL_FULL);
const CECPacket *stats = CPhPLibContext::g_curr_context->WebServer()->webInterface->SendRecvMsg_v2(&stat_req);
if (!stats) {
return ;
}
CEC_ConnState_Tag *tag = (CEC_ConnState_Tag *)stats->GetTagByName(EC_TAG_CONNSTATE);
if (!tag) {
return ;
}
cast_value_array(result);
PHP_VAR_NODE *id = array_get_by_str_key(result, "id");
cast_value_dnum(&id->value);
id->value.int_val = tag->GetEd2kId();
const CECTag *server = tag->GetTagByName(EC_TAG_SERVER);
if ( server ) {
PHP_VAR_NODE *srv_ip = array_get_by_str_key(result, "serv_addr");
value_value_free(&srv_ip->value);
srv_ip->value.type = PHP_VAL_STRING;
srv_ip->value.str_val =strdup(unicode2UTF8(server->GetIPv4Data().StringIP()));
const CECTag *sname = server->GetTagByName(EC_TAG_SERVER_NAME);
if ( sname ) {
PHP_VAR_NODE *srv_name = array_get_by_str_key(result, "serv_name");
value_value_free(&srv_name->value);
srv_name->value.type = PHP_VAL_STRING;
srv_name->value.str_val = strdup(unicode2UTF8(sname->GetStringData()));
}
const CECTag *susers = server->GetTagByName(EC_TAG_SERVER_USERS);
if ( susers ) {
PHP_VAR_NODE *srv_users = array_get_by_str_key(result, "serv_users");
value_value_free(&srv_users->value);
srv_users->value.type = PHP_VAL_INT;
srv_users->value.int_val = susers->GetInt();
}
}
// kademlia
PHP_VAR_NODE *kad = array_get_by_str_key(result, "kad_connected");
value_value_free(&kad->value);
kad->value.type = PHP_VAL_BOOL;
if ( tag->IsConnectedKademlia() ) {
kad->value.int_val = 1;
PHP_VAR_NODE *kad_fwl = array_get_by_str_key(result, "kad_firewalled");
kad_fwl->value.type = PHP_VAL_BOOL;
kad_fwl->value.int_val = tag->IsKadFirewalled();
} else {
kad->value.int_val = 0;
}
// traffic stats
PHP_VAR_NODE *speed;
speed = array_get_by_str_key(result, "speed_up");
value_value_free(&speed->value);
speed->value.type = PHP_VAL_INT;
speed->value.int_val = stats->GetTagByName(EC_TAG_STATS_UL_SPEED)->GetInt();
speed = array_get_by_str_key(result, "speed_down");
value_value_free(&speed->value);
speed->value.type = PHP_VAL_INT;
speed->value.int_val = stats->GetTagByName(EC_TAG_STATS_DL_SPEED)->GetInt();
speed = array_get_by_str_key(result, "speed_limit_up");
value_value_free(&speed->value);
speed->value.type = PHP_VAL_INT;
speed->value.int_val = stats->GetTagByName(EC_TAG_STATS_UL_SPEED_LIMIT)->GetInt();
speed = array_get_by_str_key(result, "speed_limit_down");
value_value_free(&speed->value);
speed->value.type = PHP_VAL_INT;
speed->value.int_val = stats->GetTagByName(EC_TAG_STATS_DL_SPEED_LIMIT)->GetInt();
delete stats;
}
