<?php
$_GET['ajaxagent'] = addslashes($_GET['ajaxagent']);
$_GET['this_url'] = addslashes($_GET['this_url']);

$_GET['ajaxagent'] = htmlspecialchars($_GET['ajaxagent']);
$_GET['this_url'] = htmlspecialchars($_GET['this_url']);

if(isset($_GET['ajaxagent']) && $_GET['ajaxagent']=='js') {
?>
<!--

var JSON = {
    
    stringify: function (v) {
        var a = [];

        function e(s) {
            a[a.length] = s;
        }

        function g(x) {
            var c, i, l, v;

            switch (typeof x) {
            case 'object':
                if (x) {
                    if (x instanceof Array) {
                        e('[');
                        l = a.length;
                        for (i = 0; i < x.length; i += 1) {
                            v = x[i];
                            if (typeof v != 'undefined' &&
                                    typeof v != 'function') {
                                if (l < a.length) {
                                    e(',');
                                }
                                g(v);
                            }
                        }
                        e(']');
                        return;
                    } else if (typeof x.toString != 'undefined') {
                        e('{');
                        l = a.length;
                        for (i in x) {
                            v = x[i];
                            if (x.hasOwnProperty(i) &&
                                    typeof v != 'undefined' &&
                                    typeof v != 'function') {
                                if (l < a.length) {
                                    e(',');
                                }
                                g(i);
                                e(':');
                                g(v);
                            }
                        }
                        return e('}');
                    }
                }
                e('null');
                return;
            case 'number':
                e(isFinite(x) ? +x : 'null');
                return;
            case 'string':
                l = x.length;
                e('"');
                for (i = 0; i < l; i += 1) {
                    c = x.charAt(i);
                    if (c >= ' ') {
                        if (c == '\\' || c == '"') {
                            e('\\');
                        }
                        e(c);
                    } else {
                        switch (c) {
                        case '\b':
                            e('\\b');
                            break;
                        case '\f':
                            e('\\f');
                            break;
                        case '\n':
                            e('\\n');
                            break;
                        case '\r':
                            e('\\r');
                            break;
                        case '\t':
                            e('\\t');
                            break;
                        default:
                            c = c.charCodeAt();
                            e('\\u00' + Math.floor(c / 16).toString(16) +
                                (c % 16).toString(16));
                        }
                    }
                }
                e('"');
                return;
            case 'boolean':
                e(String(x));
                return;
            default:
                e('null');
                return;
            }
        }
        g(v);
        return a.join('');
    },

    parse: function (text) {
        return (/^(\s+|[,:{}\[\]]|"(\\["\\\/bfnrtu]|[^\x00-\x1f"\\]+)*"|-?\d+(\.\d*)?([eE][+-]?\d+)?|true|false|null)+$/.test(text)) &&
            eval('(' + text + ')');
    }
};


var this_url = "<?php echo $_GET['this_url']; ?>";
var Agent_ShowWorking = 1;
var Agent_ShowWorkingDiv = 'AjaxWorking';  // Name of the div we would like to show / hide
var Agent_Showing = 0;
function AgentWorking(display){
    if(Agent_ShowWorking && document.getElementById(Agent_ShowWorkingDiv)){
        if(display == true){
        Agent_Showing++;
          document.getElementById(Agent_ShowWorkingDiv).style.display = 'inline';
        }else{
             Agent_Showing--;
             if(Agent_Showing <= 0 && document.getElementById(Agent_ShowWorkingDiv)){
                 document.getElementById(Agent_ShowWorkingDiv).style.display = 'none';
           }
        }
    }
}

function Agent() {
  this.debug = false;
  this.call = function () {
    var aa_sfunc = "";
    var aa_cfunc = "";
    var result = "";
    var xmlHttpObject;
    if(arguments.length<3) {
      finish();
      return false;
    }
    var aa_url=arguments[0];
    aa_sfunc=arguments[1];
    aa_cfunc=arguments[2];

    if((aa_url==null)||(aa_url=="")) aa_url = this_url;
    var aa_poststr = "aa_afunc=call&aa_sfunc=" + encodeURI(aa_sfunc) +
        "&aa_cfunc=" + encodeURI(aa_cfunc);
    for(var i=3; i<arguments.length; i++) {
      if(typeof(arguments[i])=='object') {
        aa_poststr += "&aa_sfunc_args[]="+encodeURIComponent(JSON.stringify(arguments[i]));
      } else {
        aa_poststr += "&aa_sfunc_args[]="+encodeURIComponent(arguments[i]);
      }
    }
    xmlHttpObject = false;
    if (window.XMLHttpRequest) {
       xmlHttpObject = new XMLHttpRequest();
    } else if (window.ActiveXObject) {
       try {
          xmlHttpObject = new ActiveXObject("Msxml2.XMLHTTP");
       } catch (e) {
          try {
             xmlHttpObject = new ActiveXObject("Microsoft.XMLHTTP");
          } catch (e) {}
       }
    }
    if (!xmlHttpObject) {
       finish();
       return false;
    }

    if((aa_sfunc==null)||(aa_sfunc=="")) {  
      if(arguments[3]) aa_poststr=arguments[3];
    }

    if((aa_cfunc==null)||(aa_cfunc=="")) {
        AgentWorking(true);
      xmlHttpObject.open('POST', aa_url, false);
      xmlHttpObject.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
      xmlHttpObject.send(aa_poststr);
      result = xmlHttpObject.responseText;
         var res = JSON.parse(result);
        AgentWorking(false);
         if (res === false)
          return result;
      else
             return res;
    } else {
      xmlHttpObject.onreadystatechange = function () {
        if (xmlHttpObject.readyState == 4) {
           if (xmlHttpObject.status == 200) {
              result = xmlHttpObject.responseText;
              if(document.getElementById(aa_cfunc)) {
          var res = JSON.parse(result);
          if (res === false)
              res = result;
                try {
                  document.getElementById(aa_cfunc).innerHTML=res;
                }
                catch (e) {
                  document.getElementById(aa_cfunc).value=res;
                }
              } else {
                var res = JSON.parse(result);
                          if (res === false)
                  eval(aa_cfunc+"(result);");
                                else 
                  eval(aa_cfunc+"(res);");
              }
                 } else {
                    if(xmlHttpObject.status!=0) {
                finish();
              }
           }
                 AgentWorking(false);
        }
      }
      xmlHttpObject.open('POST', aa_url, true);
      xmlHttpObject.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
      xmlHttpObject.send(aa_poststr);
        AgentWorking(true);
      return xmlHttpObject;
    }
    return false;
  }
  this.listen = function (aa_event, aa_cfunc) {
  }
}
var agent = new Agent();

//-->
<?php
exit();
}

define('SERVICES_JSON_SLICE',   1);
define('SERVICES_JSON_IN_STR',  2);
define('SERVICES_JSON_IN_ARR',  3);
define('SERVICES_JSON_IN_OBJ',  4);
define('SERVICES_JSON_IN_CMT', 5);
define('SERVICES_JSON_LOOSE_TYPE', 16);
define('SERVICES_JSON_SUPPRESS_ERRORS', 32);

class Services_JSON
{
    function Services_JSON($use = 0)
    {
        $this->use = $use;
    }

    function utf162utf8($utf16)
    {
        if(function_exists('mb_convert_encoding')) {
            return mb_convert_encoding($utf16, 'UTF-8', 'UTF-16');
        }

        $bytes = (ord($utf16{0}) << 8) | ord($utf16{1});

        switch(true) {
            case ((0x7F & $bytes) == $bytes):
                return chr(0x7F & $bytes);

            case (0x07FF & $bytes) == $bytes:
                return chr(0xC0 | (($bytes >> 6) & 0x1F))
                     . chr(0x80 | ($bytes & 0x3F));

            case (0xFFFF & $bytes) == $bytes:
                return chr(0xE0 | (($bytes >> 12) & 0x0F))
                     . chr(0x80 | (($bytes >> 6) & 0x3F))
                     . chr(0x80 | ($bytes & 0x3F));
        }
        return '';
    }

    function utf82utf16($utf8)
    {
        if(function_exists('mb_convert_encoding')) {
            return mb_convert_encoding($utf8, 'UTF-16', 'UTF-8');
        }

        switch(strlen($utf8)) {
            case 1:
                return $utf8;

            case 2:
                return chr(0x07 & (ord($utf8{0}) >> 2))
                     . chr((0xC0 & (ord($utf8{0}) << 6))
                         | (0x3F & ord($utf8{1})));

            case 3:
                return chr((0xF0 & (ord($utf8{0}) << 4))
                         | (0x0F & (ord($utf8{1}) >> 2)))
                     . chr((0xC0 & (ord($utf8{1}) << 6))
                         | (0x7F & ord($utf8{2})));
        }

        return '';
    }

    function encode($var)
    {
        switch (gettype($var)) {
            case 'boolean':
                return $var ? 'true' : 'false';

            case 'NULL':
                return 'null';

            case 'integer':
                return (int) $var;

            case 'double':
            case 'float':
                return (float) $var;

            case 'string':
                $ascii = '';
                $strlen_var = strlen($var);

                for ($c = 0; $c < $strlen_var; ++$c) {

                    $ord_var_c = ord($var{$c});

                    switch (true) {
                        case $ord_var_c == 0x08:
                            $ascii .= '\b';
                            break;
                        case $ord_var_c == 0x09:
                            $ascii .= '\t';
                            break;
                        case $ord_var_c == 0x0A:
                            $ascii .= '\n';
                            break;
                        case $ord_var_c == 0x0C:
                            $ascii .= '\f';
                            break;
                        case $ord_var_c == 0x0D:
                            $ascii .= '\r';
                            break;

                        case $ord_var_c == 0x22:
                        case $ord_var_c == 0x2F:
                        case $ord_var_c == 0x5C:
                            $ascii .= '\\'.$var{$c};
                            break;

                        case (($ord_var_c >= 0x20) && ($ord_var_c <= 0x7F)):
                            $ascii .= $var{$c};
                            break;

                        case (($ord_var_c & 0xE0) == 0xC0):
                            $char = pack('C*', $ord_var_c, ord($var{$c + 1}));
                            $c += 1;
                            $utf16 = $this->utf82utf16($char);
                            $ascii .= sprintf('\u%04s', bin2hex($utf16));
                            break;

                        case (($ord_var_c & 0xF0) == 0xE0):
                            $char = pack('C*', $ord_var_c,
                                         ord($var{$c + 1}),
                                         ord($var{$c + 2}));
                            $c += 2;
                            $utf16 = $this->utf82utf16($char);
                            $ascii .= sprintf('\u%04s', bin2hex($utf16));
                            break;

                        case (($ord_var_c & 0xF8) == 0xF0):
                            $char = pack('C*', $ord_var_c,
                                         ord($var{$c + 1}),
                                         ord($var{$c + 2}),
                                         ord($var{$c + 3}));
                            $c += 3;
                            $utf16 = $this->utf82utf16($char);
                            $ascii .= sprintf('\u%04s', bin2hex($utf16));
                            break;

                        case (($ord_var_c & 0xFC) == 0xF8):
                            $char = pack('C*', $ord_var_c,
                                         ord($var{$c + 1}),
                                         ord($var{$c + 2}),
                                         ord($var{$c + 3}),
                                         ord($var{$c + 4}));
                            $c += 4;
                            $utf16 = $this->utf82utf16($char);
                            $ascii .= sprintf('\u%04s', bin2hex($utf16));
                            break;

                        case (($ord_var_c & 0xFE) == 0xFC):
                            $char = pack('C*', $ord_var_c,
                                         ord($var{$c + 1}),
                                         ord($var{$c + 2}),
                                         ord($var{$c + 3}),
                                         ord($var{$c + 4}),
                                         ord($var{$c + 5}));
                            $c += 5;
                            $utf16 = $this->utf82utf16($char);
                            $ascii .= sprintf('\u%04s', bin2hex($utf16));
                            break;
                    }
                }

                return '"'.$ascii.'"';

            case 'array':
                if (is_array($var) && count($var) && (array_keys($var) !== range(0, sizeof($var) - 1))) {
                    $properties = array_map(array($this, 'name_value'),
                                            array_keys($var),
                                            array_values($var));

                    foreach($properties as $property) {
                        if(Services_JSON::isError($property)) {
                            return $property;
                        }
                    }

                    return '{' . join(',', $properties) . '}';
                }

                $elements = array_map(array($this, 'encode'), $var);

                foreach($elements as $element) {
                    if(Services_JSON::isError($element)) {
                        return $element;
                    }
                }

                return '[' . join(',', $elements) . ']';

            case 'object':
                $vars = get_object_vars($var);

                $properties = array_map(array($this, 'name_value'),
                                        array_keys($vars),
                                        array_values($vars));

                foreach($properties as $property) {
                    if(Services_JSON::isError($property)) {
                        return $property;
                    }
                }

                return '{' . join(',', $properties) . '}';

            default:
                return ($this->use & SERVICES_JSON_SUPPRESS_ERRORS)
                    ? 'null'
                    : new Services_JSON_Error(gettype($var)." can not be encoded as JSON string");
        }
    }

    function name_value($name, $value)
    {
        $encoded_value = $this->encode($value);

        if(Services_JSON::isError($encoded_value)) {
            return $encoded_value;
        }

        return $this->encode(strval($name)) . ':' . $encoded_value;
    }

    function reduce_string($str)
    {
        $str = preg_replace(array(

                '#^\s*//(.+)$#m',

                '#^\s*/\*(.+)\*/#Us',

                '#/\*(.+)\*/\s*$#Us'

            ), '', $str);

        return trim($str);
    }

    function decode($str)
    {
        $str = $this->reduce_string($str);

        switch (strtolower($str)) {
            case 'true':
                return true;

            case 'false':
                return false;

            case 'null':
                return null;

            default:
                $m = array();

                if (is_numeric($str)) {
                    return ((float)$str == (integer)$str)
                        ? (integer)$str
                        : (float)$str;

                } elseif (preg_match('/^("|\').*(\1)$/s', $str, $m) && $m[1] == $m[2]) {
                    $delim = substr($str, 0, 1);
                    $chrs = substr($str, 1, -1);
                    $utf8 = '';
                    $strlen_chrs = strlen($chrs);

                    for ($c = 0; $c < $strlen_chrs; ++$c) {

                        $substr_chrs_c_2 = substr($chrs, $c, 2);
                        $ord_chrs_c = ord($chrs{$c});

                        switch (true) {
                            case $substr_chrs_c_2 == '\b':
                                $utf8 .= chr(0x08);
                                ++$c;
                                break;
                            case $substr_chrs_c_2 == '\t':
                                $utf8 .= chr(0x09);
                                ++$c;
                                break;
                            case $substr_chrs_c_2 == '\n':
                                $utf8 .= chr(0x0A);
                                ++$c;
                                break;
                            case $substr_chrs_c_2 == '\f':
                                $utf8 .= chr(0x0C);
                                ++$c;
                                break;
                            case $substr_chrs_c_2 == '\r':
                                $utf8 .= chr(0x0D);
                                ++$c;
                                break;

                            case $substr_chrs_c_2 == '\\"':
                            case $substr_chrs_c_2 == '\\\'':
                            case $substr_chrs_c_2 == '\\\\':
                            case $substr_chrs_c_2 == '\\/':
                                if (($delim == '"' && $substr_chrs_c_2 != '\\\'') ||
                                   ($delim == "'" && $substr_chrs_c_2 != '\\"')) {
                                    $utf8 .= $chrs{++$c};
                                }
                                break;

                            case preg_match('/\\\u[0-9A-F]{4}/i', substr($chrs, $c, 6)):
                                $utf16 = chr(hexdec(substr($chrs, ($c + 2), 2)))
                                       . chr(hexdec(substr($chrs, ($c + 4), 2)));
                                $utf8 .= $this->utf162utf8($utf16);
                                $c += 5;
                                break;

                            case ($ord_chrs_c >= 0x20) && ($ord_chrs_c <= 0x7F):
                                $utf8 .= $chrs{$c};
                                break;

                            case ($ord_chrs_c & 0xE0) == 0xC0:
                                $utf8 .= substr($chrs, $c, 2);
                                ++$c;
                                break;

                            case ($ord_chrs_c & 0xF0) == 0xE0:
                                $utf8 .= substr($chrs, $c, 3);
                                $c += 2;
                                break;

                            case ($ord_chrs_c & 0xF8) == 0xF0:
                                $utf8 .= substr($chrs, $c, 4);
                                $c += 3;
                                break;

                            case ($ord_chrs_c & 0xFC) == 0xF8:
                                $utf8 .= substr($chrs, $c, 5);
                                $c += 4;
                                break;

                            case ($ord_chrs_c & 0xFE) == 0xFC:
                                $utf8 .= substr($chrs, $c, 6);
                                $c += 5;
                                break;

                        }

                    }

                    return $utf8;

                } elseif (preg_match('/^\[.*\]$/s', $str) || preg_match('/^\{.*\}$/s', $str)) {

                    if ($str{0} == '[') {
                        $stk = array(SERVICES_JSON_IN_ARR);
                        $arr = array();
                    } else {
                        if ($this->use & SERVICES_JSON_LOOSE_TYPE) {
                            $stk = array(SERVICES_JSON_IN_OBJ);
                            $obj = array();
                        } else {
                            $stk = array(SERVICES_JSON_IN_OBJ);
                            $obj = new stdClass();
                        }
                    }

                    array_push($stk, array('what'  => SERVICES_JSON_SLICE,
                                           'where' => 0,
                                           'delim' => false));

                    $chrs = substr($str, 1, -1);
                    $chrs = $this->reduce_string($chrs);

                    if ($chrs == '') {
                        if (reset($stk) == SERVICES_JSON_IN_ARR) {
                            return $arr;

                        } else {
                            return $obj;

                        }
                    }

                    $strlen_chrs = strlen($chrs);

                    for ($c = 0; $c <= $strlen_chrs; ++$c) {

                        $top = end($stk);
                        $substr_chrs_c_2 = substr($chrs, $c, 2);

                        if (($c == $strlen_chrs) || (($chrs{$c} == ',') && ($top['what'] == SERVICES_JSON_SLICE))) {
                            $slice = substr($chrs, $top['where'], ($c - $top['where']));
                            array_push($stk, array('what' => SERVICES_JSON_SLICE, 'where' => ($c + 1), 'delim' => false));

                            if (reset($stk) == SERVICES_JSON_IN_ARR) {
                                array_push($arr, $this->decode($slice));

                            } elseif (reset($stk) == SERVICES_JSON_IN_OBJ) {
                                $parts = array();
                                
                                if (preg_match('/^\s*(["\'].*[^\\\]["\'])\s*:\s*(\S.*),?$/Uis', $slice, $parts)) {
                                    $key = $this->decode($parts[1]);
                                    $val = $this->decode($parts[2]);

                                    if ($this->use & SERVICES_JSON_LOOSE_TYPE) {
                                        $obj[$key] = $val;
                                    } else {
                                        $obj->$key = $val;
                                    }
                                } elseif (preg_match('/^\s*(\w+)\s*:\s*(\S.*),?$/Uis', $slice, $parts)) {
                                    $key = $parts[1];
                                    $val = $this->decode($parts[2]);

                                    if ($this->use & SERVICES_JSON_LOOSE_TYPE) {
                                        $obj[$key] = $val;
                                    } else {
                                        $obj->$key = $val;
                                    }
                                }

                            }

                        } elseif ((($chrs{$c} == '"') || ($chrs{$c} == "'")) && ($top['what'] != SERVICES_JSON_IN_STR)) {
                            array_push($stk, array('what' => SERVICES_JSON_IN_STR, 'where' => $c, 'delim' => $chrs{$c}));

                        } elseif (($chrs{$c} == $top['delim']) &&
                                 ($top['what'] == SERVICES_JSON_IN_STR) &&
                                 ((strlen(substr($chrs, 0, $c)) - strlen(rtrim(substr($chrs, 0, $c), '\\'))) % 2 != 1)) {
                            array_pop($stk);

                        } elseif (($chrs{$c} == '[') &&
                                 in_array($top['what'], array(SERVICES_JSON_SLICE, SERVICES_JSON_IN_ARR, SERVICES_JSON_IN_OBJ))) {
                            array_push($stk, array('what' => SERVICES_JSON_IN_ARR, 'where' => $c, 'delim' => false));

                        } elseif (($chrs{$c} == ']') && ($top['what'] == SERVICES_JSON_IN_ARR)) {
                            array_pop($stk);

                        } elseif (($chrs{$c} == '{') &&
                                 in_array($top['what'], array(SERVICES_JSON_SLICE, SERVICES_JSON_IN_ARR, SERVICES_JSON_IN_OBJ))) {
                            array_push($stk, array('what' => SERVICES_JSON_IN_OBJ, 'where' => $c, 'delim' => false));

                        } elseif (($chrs{$c} == '}') && ($top['what'] == SERVICES_JSON_IN_OBJ)) {
                            array_pop($stk);

                        } elseif (($substr_chrs_c_2 == '/*') &&
                                 in_array($top['what'], array(SERVICES_JSON_SLICE, SERVICES_JSON_IN_ARR, SERVICES_JSON_IN_OBJ))) {
                            array_push($stk, array('what' => SERVICES_JSON_IN_CMT, 'where' => $c, 'delim' => false));
                            $c++;

                        } elseif (($substr_chrs_c_2 == '*/') && ($top['what'] == SERVICES_JSON_IN_CMT)) {
                            array_pop($stk);
                            $c++;

                            for ($i = $top['where']; $i <= $c; ++$i)
                                $chrs = substr_replace($chrs, ' ', $i, 1);

                        }

                    }

                    if (reset($stk) == SERVICES_JSON_IN_ARR) {
                        return $arr;

                    } elseif (reset($stk) == SERVICES_JSON_IN_OBJ) {
                        return $obj;

                    }

                }
        }
    }

    function isError($data, $code = null)
    {
        if (class_exists('pear')) {
            return PEAR::isError($data, $code);
        } elseif (is_object($data) && (get_class($data) == 'services_json_error' ||
                                 is_subclass_of($data, 'services_json_error'))) {
            return true;
        }

        return false;
    }
}

if (class_exists('PEAR_Error')) {

    class Services_JSON_Error extends PEAR_Error
    {
        function Services_JSON_Error($message = 'unknown error', $code = null,
                                     $mode = null, $options = null, $userinfo = null)
        {
            parent::PEAR_Error($message, $code, $mode, $options, $userinfo);
        }
    }

} else {

    class Services_JSON_Error
    {
        function Services_JSON_Error($message = 'unknown error', $code = null,
                                     $mode = null, $options = null, $userinfo = null)
        {

        }
    }

}

$agent = new Agent;

if(!defined('AJAXAGENT_ADVANCED'))  
    $agent->agent_process();

class Agent {
    var $_func_names = array();
    var $_prefix_name = '';
    var $_debug = true;
    var $_debug_info = '';
    var $_php52 = true;
    var $_convert_to_utf8 = false;
    var $_convert_from_utf8 = false;
    var $_magic_quotes_gpc = false;

    function Agent(){
        $this->_magic_quotes_gpc = get_magic_quotes_gpc();
    }
    
    function options($convert_to_utf8 = false, $convert_from_utf8 = false){
        if ($convert_to_utf8 == true)
            $this->_convert_to_utf8 = true;
        if ($convert_from_utf8 == true)
            $this->_convert_from_utf8 = true;
    }    

    function _check_function($aa_sfunc) {
        $arr = get_defined_functions();
        if (in_array(strtolower($aa_sfunc), $arr["user"])){
            unset($arr);
            switch (true){
            case (!empty($this->_func_names)):
                if (!in_array($aa_sfunc, $this->_func_names)){
                    $this->_debug_info = "function $aa_sfunc not registered";
                }
                break;
            case (strlen($this->_prefix_name) > 0):
                if (false === strpos($aa_sfunc, $this->_prefix_name)){
                    $this->_debug_info = "invalid function prefix in function $aa_sfunc";
                }
                break;
            }
        }else{
            $this->_debug_info = "function $aa_sfunc not defined";
        }

        if(empty($this->_debug_info))
            return true;
        else 
            return false;
    }

    function call($aa_sfunc, $aa_cfunc, $aa_sfunc_args) {
        if (true !== $this->_check_function($aa_sfunc)){
            if (true === $this->_debug){
                exit($this->_debug_info);
            }
            exit;
        }

        if (!function_exists('json_encode')){
            $json = new Services_JSON();
            $this->_php52 = false;
        }
        $aa_sfunc_args_dc=array();
        if($aa_sfunc_args && sizeof($aa_sfunc_args)>=1) {
            foreach ($aa_sfunc_args as $aa_arg) {
                if ((strpos($aa_arg, '[')!==false) || (strpos($aa_arg, '{')!==false)) {
                    if ((strpos($aa_arg, '[')===0) || (strpos($aa_arg, '{')===0)) {
                        if (true === $this->_php52){
                            $aa_arg_dc = json_decode($aa_arg);
                        }else{
                            $aa_arg_dc = $json->decode($aa_arg);
                        }
                        array_push($aa_sfunc_args_dc,$aa_arg_dc);
                    } else {
                        array_push($aa_sfunc_args_dc,$aa_arg);
                    }
                } else {
                    array_push($aa_sfunc_args_dc,$aa_arg);
                }
            }
        }

        if (count($aa_sfunc_args_dc)){
            if ($this->_convert_from_utf8){
                $aa_sfunc_args_dc = $this->do_utf8_decode_array($aa_sfunc_args_dc);
            }
            if ($this->_magic_quotes_gpc){
                $aa_sfunc_args_dc = $this->addslashes_array($aa_sfunc_args_dc);
            }
        }
            
        $ret = call_user_func_array($aa_sfunc, $aa_sfunc_args_dc);

        if ($this->_convert_to_utf8){
            if(is_array($ret) || is_object($ret)) {
                $ret = $this->do_utf8_encode_array($ret);
            }else{
                if (!$this->detectUTF8($ret))
                    $ret = utf8_encode($ret);
            }
        }
        if (true === $this->_php52){
            $ret = json_encode($ret);  
        }else{
            $ret = $json->encode($ret);  
        }        

        echo $ret;

        exit();
    }

    function listen($aa_event, $aa_cfunc, $aa_sfunc_args) {
        exit();
    }

    function agent_process(){
        if (isset($_POST['aa_afunc'])) $aa_afunc = $_POST['aa_afunc']; else $aa_afunc="";
        if (isset($_POST['aa_sfunc'])) $aa_sfunc = $_POST['aa_sfunc']; else $aa_sfunc="";
        if (isset($_POST['aa_event'])) $aa_event = $_POST['aa_event']; else $aa_event="";
        if (isset($_POST['aa_cfunc'])) $aa_cfunc = $_POST['aa_cfunc']; else $aa_cfunc="";
        if (isset($_POST['aa_sfunc_args'])) $aa_sfunc_args = $_POST['aa_sfunc_args'];
        else $aa_sfunc_args="";

        if($aa_afunc=="call") {
            if($this->_magic_quotes_gpc){
                $aa_sfunc = $this->stripslashes2($aa_sfunc);
                $aa_cfunc = $this->stripslashes2($aa_cfunc);
                $aa_sfunc_args = $this->stripslashes2($aa_sfunc_args);
            }
            $this->call($aa_sfunc, $aa_cfunc, $aa_sfunc_args);
        }

        if($aa_afunc=="listen") {
            $this->listen($aa_event, $aa_cfunc, $aa_sfunc_args);
        }
    }

    function register_func($str){
        $this->_func_names[] = $str;
    }

    function register_prefix($str){
        $this->_prefix_name = $str;
    }

    function init(){
        echo $this->init_return();
    }

    function init_return() {
        if($_SERVER['REQUEST_URI'] == null || $_SERVER['REQUEST_URI'] == "") {
            $aa_url = $_SERVER['PHP_SELF'];
        } else {
            $aa_url = $_SERVER['REQUEST_URI'];
        }
        return "<script type='text/javascript' src='http://".$_SERVER['HTTP_HOST']."/inc/agent.php?ajaxagent=js&this_url=" . urlencode($aa_url) . "'>

</script>";
    }

    function my_debug($func, $str) {
        if($this->_debug)
            syslog(LOG_NOTICE, "$func -> $str");

        if (0) {
            $filename = "/tmp/agent.log";
            $str = date("M j H:i:s - ") . $func . " - " . $str;
            if (!$handle = fopen($filename, 'a')) {
                echo "Cannot open file ($filename)";
                return;
            }
            if (fwrite($handle, $str . "\n") === FALSE) {
                echo "Cannot write to file ($filename)";
                return;
            }
            fclose($handle);
        }
    }
    
    function stripslashes2($str) {
        return str_replace(array("\\\"", "\\'", "\\\\"), array("\"", "'", "\\"), $str);
    }
    
    function detectUTF8($str) {
        return preg_match ('%(?:
            [\xC2-\xDF][\x80-\xBF]                        # non-overlong 2-byte
                |\xE0[\xA0-\xBF][\x80-\xBF]         # excluding overlongs
                |[\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
                |\xED[\x80-\x9F][\x80-\xBF]         # excluding surrogates
                |\xF0[\x90-\xBF][\x80-\xBF]{2}        # planes 1-3
                |[\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
                |\xF4[\x80-\x8F][\x80-\xBF]{2}        # plane 16
                )+%xs', $str);
    }
    
    function addslashes_array($a){
        if(is_array($a) || is_object($a)){
            foreach($a as $n => $v){
                $b[$n] = $this->addslashes_array($v);
            }
            if (isset($b))
                return $b;
            return;
        }elseif(is_string($a)){
            return addslashes($a);
        }else{
            return $a;
        }
    }
    
    function do_utf8_encode_array($a){
        if(is_array($a) || is_object($a)){
            foreach($a as $n => $v){
                $b[$n] = $this->do_utf8_encode_array($v);
            }
            if (isset($b))
                return $b;
            return;
        }elseif(!$this->detectUTF8($a)){
            return utf8_encode($a);
        }else{
            return $a;
        }
    }
    
    function do_utf8_decode_array($a){
        if(is_array($a) || is_object($a)){
            foreach($a as $n => $v){
                $b[$n] = $this->do_utf8_decode_array($v);
            }
            if (isset($b))
                return $b;
            return;
        }elseif($this->detectUTF8($a)){
            return utf8_decode($a);
        }else{
            return $a;
        }
    }
}
?>
