general.inc

<?php
function gpc_stripslashes($var)
{
    if (get_magic_quotes_gpc()) {
        if (is_array($var)) {
            stripslashes_array($var, TRUE);
        } else {
            $var = stripslashes($var);
        }
    }
    return $var;

}//end gpc_stripslashes()


function stripslashes_array(&$array, $strip_keys=FALSE)
{
    if (is_string($array)) return stripslashes($array);
    $keys_to_replace = Array();
    foreach ($array as $key => $value) {
        if (is_string($value)) {
            $array[$key] = stripslashes($value);
        } else if (is_array($value)) {
            stripslashes_array($array[$key], $strip_keys);
        }

        if ($strip_keys && $key != ($stripped_key = stripslashes($key))) {
            $keys_to_replace[$key] = $stripped_key;
        }
    }
    // now replace any of the keys that needed strip slashing
    foreach ($keys_to_replace as $from => $to) {
        $array[$to]   = &$array[$from];
        unset($array[$from]);
    }
    return $array;

}//end stripslashes_array()


function htmlentities_array(&$array, $encode_keys=FALSE)
{
    // type verification
    if ((!is_array($array) && !is_string($array)) || !is_bool($encode_keys)) {
        return Array();
    }

    if (is_string($array)) return htmlentities($array, ENT_COMPAT, SQ_CONF_DEFAULT_CHARACTER_SET);
    $keys_to_replace = Array();
    foreach ($array as $key => $value) {
        if (is_string($value)) {
            $array[$key] = htmlentities($value, ENT_COMPAT, SQ_CONF_DEFAULT_CHARACTER_SET);
        } else if (is_array($value)) {
            htmlentities_array($array[$key], $encode_keys);
        }

        if ($encode_keys && $key != ($encoded_key = htmlentities($key, ENT_COMPAT, SQ_CONF_DEFAULT_CHARACTER_SET))) {
            $keys_to_replace[$key] = $encoded_key;
        }
    }
    // now replace any of the keys that needed encoding
    foreach ($keys_to_replace as $from => $to) {
        $array[$to] = &$array[$from];
        unset($array[$from]);
    }
    return $array;

}//end htmlentities_array()


function array_remove_element($v, &$a)
{
    if (!is_array($a) || empty($a)) {
        return FALSE;
    }
    if (in_array($v,$a)) {
        unset($a[array_search($v,$a)]);
        return TRUE;
    }

}//end array_remove_element()


function array_merge_multi($array1, $array2)
{
    // type verification
    if (!is_array($array1) || !is_array($array2)) {
        return Array();
    }

    if (empty($array2)) return $array1;

    return _array_merge_multi_recursive($array1, $array2);

}//end array_merge_multi()


function _array_merge_multi_recursive($array1, $array2)
{
    foreach ($array2 as $key => $value) {
        if (is_array($value)) {
            if (!array_key_exists($key, $array1)) {
                $array1[$key] = Array();
            }
            $array1[$key] = _array_merge_multi_recursive($array1[$key], $value);
        } else {
            if (!is_array($array1)) $array1 = Array();
            $array1[$key] = $value;
        }
    }

    return $array1;

}//end _array_merge_multi_recursive()


function array_flatten($array, $prune_parents=FALSE, $return_unique_keys=TRUE)
{
    if (!is_array($array) || empty($array)) {
        return Array();
    }

    $flattened_array = Array();

    foreach ($array as $key => $value) {
        if (is_array($value)) {
            if (!$prune_parents) {
                if ($return_unique_keys) {
                    $flattened_array[$key] = Array();
                } else {
                    $flattened_array[] = $key;
                }
            }

            if ($return_unique_keys) {
                $flattened_array += array_flatten($value, $prune_parents, $return_unique_keys);
            } else {
                foreach (array_flatten($value, $prune_parents, $return_unique_keys) as $flattened_value) {
                    $flattened_array[] = $flattened_value;
                }
            }
        } else {
            if ($return_unique_keys) {
                $flattened_array[$key] = $value;
            } else {
                $flattened_array[] = $key;
            }
        }
    }

    return $flattened_array;

}//end array_flatten()


function dal_array_flatten($array, $column='')
{
    if (!is_array($array) || empty($array)) {
        return Array();
    }

    $flattened_array = Array();
    // drill down until we find a 0 index which means we may have have found a valid row
    while (is_array($array) && !empty($array)) {
        foreach ($array as $id => $data) {
            if (is_array($data) && $id !== 0) {
                // 1 level lookahead to see if we are about to find a valid row
                // if we do then start iterating to capture all other rows
                if (empty($column)) {
                    // if the column name is not specified return the array found there instead
                    if (isset($array[$id][0])) {
                        foreach ($array as $question_id => $type_data) {
                            $flattened_array[$question_id] = $type_data[0];
                        }
                        break(2);
                    }
                } else {
                    if (isset($array[$id][0]) && isset($array[$id][0][$column])) {
                        foreach ($array as $question_id => $type_data) {
                            $flattened_array[$question_id] = $type_data[0][$column];
                        }
                        break(2);
                    }
                }
            }
            $array = $data;
        }
    }

    return $flattened_array;

}//end dal_array_flatten()


function random_password($length, $include_uppercase=FALSE, $include_numbers=FALSE)
{
    if (!$length) $length = 8;
    $letters            = 'bcdfghjklnpqrstvwyz';
    
    // Please note that certain letters and numbers are missing due to being represented in a similar manner to lowercase chars in some fonts
    $numbers            = '2346789';
    $upper_letters      = 'DFGHLNQRT';

    $password   = '';

    //As of PHP 4.2.0, there is no need to seed the random number generator, it is done automatically by rand()
    //global $RANDOM_PASSWORD_SEED;

    // If we are including uppercase characters, ensure at least one is present
    $uppercase_indexes = Array();
    $chosen_default_uppercase_index = rand(0, $length-1);
    //$seed = $RANDOM_PASSWORD_SEED + $length + ((int)(100000 * (double)microtime())) + time();
    if (($include_uppercase) && ($length > 1)) {
        //srand($seed);

        $uppercase_indexes[$chosen_default_uppercase_index] = 1;
        $num_added = 1;

        // Make between 1 character and 1/2 of the string an uppercase letter
        for ($n=0; $n<$length; $n++) {
            if ((rand(0,3) == 0) && ($num_added < ($length/2))) {
                $uppercase_indexes[$n] = 1;
                $num_added++;
            }
        }
    }

    // If we are including numbers, ensure at least one is present
    $number_indexes = Array();
    if (($include_numbers) && ($length > 2)) {
        //srand($seed);

        // Ensure that we don't place our initial inserted number over the top of an uppercase letter
        $chosen_default_number_index = rand(0, $length-1);
        while (isset($uppercase_indexes[$chosen_default_number_index])) {
            $chosen_default_number_index = rand(0, $length-1);
        }

        $number_indexes[$chosen_default_number_index] = 1;
        $num_added = 1;

        // Make between 1 character and 1/3 of the string a number
        for ($n=0; $n<$length; $n++) {
            if ((rand(0,4) == 0) && ($num_added < ($length/3))) {
                $number_indexes[$n] = 1;
                $num_added++;
            }
        }
    }

    $current_index = 0;
    while ($length > 0) {
        //$RANDOM_PASSWORD_SEED += $length;
        //$seed = $RANDOM_PASSWORD_SEED + $length + ((int)(100000 * (double)microtime())) + time();
        //srand($seed);
        $appended_characters = $letters[rand(0,strlen($letters)-1)];

        // Assign either an uppercase letter or a number if we are destined to do so
        if (($include_uppercase) && (isset($uppercase_indexes[$current_index]))) {
            $appended_characters = $upper_letters[rand(0,strlen($upper_letters)-1)];
        } else if (($include_numbers) && (isset($number_indexes[$current_index]))) {
            $appended_characters = $numbers[rand(0,strlen($numbers)-1)];
        }
        $current_index++;

        $password .= $appended_characters;
        $length -= 1;
    }//end while
    //$RANDOM_PASSWORD_SEED++;

    return $password;

}//end random_password()


function random_user_password($userinfo = Array())
{
    $config = new Password_Rules_Config();
    require_once $config->config_file;
    
    $password = generate_random_user_password();
    
    // check if this password contains blacklisted word
    $retry_max = 99;
    $blacklist = SQ_PASSWD_RULE_BLACK_LIST;
    $blacklist = str_replace("\r\n","\n", $blacklist);
    $blacklist = str_replace("\r","\n", $blacklist);
    $blacklist = explode("\n", $blacklist);
    
    for($i=0;  $i<$retry_max; $i++) {
    $retry = FALSE;
     if (!empty($blacklist)){
        foreach ($blacklist as $word) {
        if ((!SQ_PASSWD_RULE_BLACK_LIST_EXACT && preg_match('/'.$word.'/', $password)) || (SQ_PASSWD_RULE_BLACK_LIST_EXACT && (strcmp($password, $word) == 0))) {
            $retry = TRUE;
         }
        }
     }
    if(!empty($userinfo) && defined('SQ_PASSWD_RULE_DISALLOW_USER_INFO') && SQ_PASSWD_RULE_DISALLOW_USER_INFO == 0) {
        foreach ($userinfo as $component) {
        if (!empty($component) && preg_match('/.*'.$component.'.*/i', $password)) {
            $retry = TRUE;
        }
        }
    }
    if(trim($password) !== $password) $retry = TRUE;
    if($retry) {
        // regenerate a new password
        // if it's hopeless, just return empty password
        $i == $retry_max - 1 ? $password = '' : $password =  generate_random_user_password();
    }
    else {
        break;
    }
    }
  
    return $password;
}//end random_user_password()


function generate_random_user_password ()
{
    $config = new Password_Rules_Config();
    require_once $config->config_file;
    $capital_chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
    $lowercase_chars = 'abcdefghijklmnopqrstuvwxyz';
    $numers = '0123456789';
    $punc_chars = ',.?!';
    $allowed_chars = '';
    $total_length = 12;
    $password = '';


    if (defined('SQ_PASSWD_RULE_LENGTH') && SQ_PASSWD_RULE_LENGTH > -1) {
        $total_length = SQ_PASSWD_RULE_LENGTH;
    }
    $left_length = $total_length;
    // add minimum required chars
    if (defined('SQ_PASSWD_RULE_NUM_CAPS') && SQ_PASSWD_RULE_NUM_CAPS > -1) {
        $password .= randString(SQ_PASSWD_RULE_NUM_CAPS, $capital_chars);
        $left_length -= SQ_PASSWD_RULE_NUM_CAPS;
        if(SQ_PASSWD_RULE_NUM_CAPS === 0) $allowed_chars .= $capital_chars;
    }
    if (defined('SQ_PASSWD_RULE_NUM_LOWER') && SQ_PASSWD_RULE_NUM_LOWER > -1) {
        $password .=  randString(SQ_PASSWD_RULE_NUM_LOWER, $lowercase_chars);
    $left_length -= SQ_PASSWD_RULE_NUM_LOWER;
        if(SQ_PASSWD_RULE_NUM_LOWER === 0) $allowed_chars .= $lowercase_chars;
    }
    if (defined('SQ_PASSWD_RULE_NUM_INT') && SQ_PASSWD_RULE_NUM_INT > -1) {
        $password .=   randString(SQ_PASSWD_RULE_NUM_INT, $numers);
        $left_length -= SQ_PASSWD_RULE_NUM_INT;
        if(SQ_PASSWD_RULE_NUM_INT === 0) $allowed_chars .= $numers;
    }
    if (defined('SQ_PASSWD_RULE_NUM_PUNC') && SQ_PASSWD_RULE_NUM_PUNC > -1) {
        $password .= randString(SQ_PASSWD_RULE_NUM_PUNC, $punc_chars);
        $left_length -= SQ_PASSWD_RULE_NUM_PUNC;
        if(SQ_PASSWD_RULE_NUM_PUNC === 0) $allowed_chars .= $punc_chars;
    }
    if (defined('SQ_PASSWD_RULE_NUM_SPC') && SQ_PASSWD_RULE_NUM_SPC > -1) {
        $password .=   randString(SQ_PASSWD_RULE_NUM_SPC, ' ');
        $left_length -= SQ_PASSWD_RULE_NUM_SPC;
        if(SQ_PASSWD_RULE_NUM_SPC === 0) $allowed_chars .= ' ';
    }

    // add rest from allowed chars
    $password .=   randString($left_length, $allowed_chars);

    // shuffle
    $password =  str_shuffle($password);


    return $password;

}//end generate_random_user_password()


    function randString($length, $source)
    {
    $return = '';
    for ($i =0; $i< $length; $i++) {
        $int = rand(0,  strlen($source) - 1);
        $return .= $source[$int];
    }
    return $return;
    }//end randString
    
    
     function arrayToXml($array, &$xml)
     {  foreach($array as $key => $value) {
        // remove characters for valid XML
        $key = preg_replace('/[^a-zA-Z_\-+0-9]+/', '_', $key);
        if(is_numeric($key)) $key = '_'.$key;

        // single element no need of index
        if(is_array($value) && count($value) == 1 && isset($value[0]) && !is_array($value[0])) {
            $xml->addChild("$key","$value[0]");
            continue;
        }

        if(is_array($value)) {
        $subnode = $xml->addChild("$key");
        arrayToXml($value, $subnode);
        }
        else {
        $xml->addChild("$key","$value");
        }
    }
    }//end arrayToXml()
    
    
function ellipsisize($string, $length)
{   
    // type verification
    if (!is_string($string) || !is_int($length) ) {
        return '';
    }

    // boundary check #1 - length needs to be at least zero
    if ($length < 0) return '';

    // boundary check #2 - if the string isn't long enough to contract, return
    // it unedited
    if (strlen($string) <= $length) return $string;

    $full_length = strlen((string) $string);
    $length += 2; // add 2 because an elipsis is 3 chars long
    $on = TRUE;
    $j = 0;
    for ($i = 0; $i < $full_length; $i++) {
        if ($j == $length - 2)  $chophere = $i;
        if ($on) {
            if ($string[$i] == '<') {
                $on = FALSE;
            } else {
                $j++;
            }
        } else {
            if ($string[$i] == '>') $on = TRUE;
        }
    }
    if ($length < $j) {
        $string = substr($string, 0, $chophere).'...';
    }
    
    $string = check_char_encoding($string); 
        
    return $string;

}//end ellipsisize()


function increment_name($name='', $spacer='')
{
    // type verification
    if (!is_string($name) || !is_string($spacer)) {
        return '';
    }

    $last_character = substr($name, -1);

    if (preg_match('/[^0-9]/', $last_character)) {
        // name ends with character
        return $name.$spacer.'2';

    } else if (preg_match('/^[0-9]+$/', $name)) {
        // name with only digits
        $next_number = intval($name) + 1;
        return strval($next_number);

    } else {
        // name ends with non-digit character
        if (preg_match('/(.*[^0-9]{1})(0+[0-9]+)$/', $name, $number)) {
            // name ends with digits with preceeding zeros, like 001, 0002

            if (preg_match('/^0+$/', $number[2])) {
                // all zeros, eg. hello_00000
                return $number[1].substr($number[2], 0, -1).strval(1);

            } else if (preg_match('/^(0+)([1-9]{1}[0-9]*)$/', $number[2], $number2)) {
                // some zeros and number eg. hello_01, hello_0003429
                $last_character = substr($number2[2], -1);
                $next_number = intval($number2[2]) + 1;

                if ($last_character == '9') {
                    return $number[1].substr($number2[1], 0, -1).strval($next_number);
                } else {
                    return $number[1].$number2[1].strval($next_number);
                }
            }

        } else if (preg_match('/(.*[^0-9]{1})([0-9]{1,})$/', $name, $number)) {
            // name ends with digits without preceeding zeros, like 100, 223
            $next_number = intval($number[2]) + 1;
            return $number[1].strval($next_number);
        }
    }

}//end increment_name()


function generate_security_key($key_len, $include_uppercase=FALSE, $include_numbers=FALSE)
{
    $k = random_password($key_len, $include_uppercase, $include_numbers);
    if ($key_len>10) {
        $gl=Array('YmxhaXI=','Z3JlZw==','bWFyYw==','ZG9t');
        $g=base64_decode($gl[rand(0,(count($gl)-1))]);$pos=rand(1,($key_len-strlen($g)));
        $k=substr($k,0,$pos).$g.substr($k,($pos+strlen($g)));
    }

    return $k;

}//end generate_security_key()


function security_key_image($key_len, $word, $w, $h, $bg='FFFFFF', $text='000000', $border='000000', $zoom=1, $use_colours=FALSE, $use_font=FALSE, $font='', $font_size=20, $min_angle=10, $max_angle=20, $x_start=20, $min_dist=20, $max_dist=20, $ttf_width=200, $ttf_height=36, $use_arc=FALSE, $arc_color='D20A0A')
{
    if (!empty($word)) {
        // Reset colours to defaults if we are not using them
        if (!$use_colours) {
            $bg     = 'FFFFFF'; // White background
            $text   = '000000'; // Black text
            $border = '000000'; // Black border
        }

        // cache control for this image
        header('Cache-Control:');
        header('Pragma: cache');
        header('Expires: '.gmdate('D, d M Y H:i:s',time() -1000).' GMT');
        header('Content-type: image/png');

        // create an image we will use to print the characters on and then
        // another image $zoom times bigger where we will print the larger
        // zoomed text for easier reading
        if (!($test_im = @imagecreate($w, $h))) {
            trigger_error('Cannot Initialize new GD image stream', E_USER_WARNING);
            return FALSE;
        }

        if (!$final_im = @imagecreate(($w * $zoom), ($h * $zoom))) {
            trigger_error('Cannot Initialize new GD image stream', E_USER_WARNING);
            return FALSE;
        }

        if (!$ttf_im = @imagecreate($ttf_width, $ttf_height)) {
            trigger_error('Cannot Initialize new GD image stream', E_USER_WARNING);
            return FALSE;
        }

        // create some colours we will use in the image
        // NOTE: The first colour allocated is used for the background
        $r = hexdec(substr($bg, 0, 2));
        $g = hexdec(substr($bg, 2, 2));
        $b = hexdec(substr($bg, 4, 2));
        $bg_colour = imagecolorallocate($test_im, $r, $g, $b);
        $bg_colour = imagecolorallocate($final_im, $r, $g, $b);
        $bg_colour = imagecolorallocate($ttf_im, $r, $g, $b);

        $r = hexdec(substr($text, 0, 2));
        $g = hexdec(substr($text, 2, 2));
        $b = hexdec(substr($text, 4, 2));
        $text_colour = imagecolorallocate($test_im, $r, $g, $b);
        $text_colour = imagecolorallocate($final_im, $r, $g, $b);
        $text_colour = imagecolorallocate($ttf_im, $r, $g, $b);

        $r = hexdec(substr($border, 0, 2));
        $g = hexdec(substr($border, 2, 2));
        $b = hexdec(substr($border, 4, 2));
        $border_colour = imagecolorallocate($test_im, $r, $g, $b);
        $border_colour = imagecolorallocate($final_im, $r, $g, $b);
        $border_colour = imagecolorallocate($ttf_im, $r, $g, $b);

        $r = hexdec(substr($arc_color, 0, 2));
        $g = hexdec(substr($arc_color, 2, 2));
        $b = hexdec(substr($arc_color, 4, 2));
        $arc_color_final = imagecolorallocate($ttf_im, $r, $g, $b);

        $x_pos = 5;
        $y_pos = 5;
        $chars = preg_split('//', $word, -1, PREG_SPLIT_NO_EMPTY);

        foreach ($chars as $char) {
            // print the character in either type 3, 4 or 5 inbuilt font
            imagestring ($test_im, rand(3, 5), $x_pos, $y_pos, $char, $text_colour);

            // work out the new dimensions of the character after zooming
            $new_w = rand(10, (10 * $zoom));
            $new_h = rand(15, (10 * $zoom));

            // copy the character we printed above and resize it onto the final
            // image to zoom the characet randomly in width and height based on $zoom
            if ($use_font) {

                // Trigger an error if no font file is set
                if ($font == '') {
                    trigger_error('You must select a true type font file to use', E_USER_WARNING);
                    return FALSE;
                }

                // Set some vars for our TTF image
                $angle = rand($min_angle, $max_angle);

                // Create the image
                imagettftext($ttf_im, $font_size, $angle, $x_start, $font_size + 10, $text_colour, $font, $char);
                // increase the x position
                $x_start += rand($min_dist, $max_dist);
            } else {
                imagecopyresized($final_im, $test_im, ($x_pos * $zoom), ($y_pos * $zoom), $x_pos, $y_pos, $new_w, $new_h, 10, 15);
                // increase the x position
                $x_pos += 10;
            }

        }//end foreach

        // Check to see if we are using arcs
        if ($use_arc && $use_font) {
            imagesetthickness($ttf_im, 3);

            // Create the first arc on our image
            $xpos   = 5 + ($font_size * 2) + rand(-5, 5);
            $arc_width  = $ttf_width / 4.66 + rand(3, 10);
            $arc_height = $font_size * 2.14 - rand(3, 10);

            if ( rand(0,100) % 2 == 0 ) {
              $start = rand(0,66);
              $ypos  = $ttf_height / 2 - rand(5, 15);
              $xpos += rand(5, 10);
            } else {
              $start = rand(180, 246);
              $ypos  = $ttf_height / 2 + rand(5, 15);
            }

            $end = $start + rand(75, 110);
            imagearc($ttf_im, $xpos, $ypos, $arc_width, $arc_height, $start, $end, $arc_color_final);
            //end first arc

            // Create the second arc on our image
            $arc_color = imagecolorallocate($ttf_im,   0,   0, 255);
            $xpos   = 5 + ($font_size * 2) + rand(-5, 5);
            $arc_width  = $ttf_width / 4.66 + rand(3, 10);
            $arc_height = $font_size * 2.14 - rand(3, 10);

            if ( rand(1,75) % 2 == 0 ) {
              $start = rand(45,110);
              $ypos  = $ttf_height / 2 - rand(5, 15);
              $xpos += rand(5, 15);
            } else {
              $start = rand(200, 250);
              $ypos  = $ttf_height / 2 + rand(5, 15);
            }

            $end = $start + rand(75, 100);
            imagearc($ttf_im, $ttf_width * .75, $ypos, $arc_width, $arc_height, $start, $end, $arc_color_final);
            //end second arc

        }//end if


        if ($use_font) {
            imagerectangle($ttf_im, 0, 0, imagesx($ttf_im) -1, imagesy($ttf_im) -1, $border_colour);
            // Create our image as a png then destroy
            imagepng($ttf_im);
            imagedestroy($ttf_im);
        } else {
            // draw a border around the outside
            imagerectangle($final_im, 0, 0, ($w * $zoom) -1, ($h * $zoom) -1, $border_colour);

            // output the image
            imagepng($final_im);

            // cleanup
            imagedestroy($test_im);
            imagedestroy($final_im);
        }

    }//end if empty($word)

}//end security_key_image()


function add_ordinal_suffix($num)
{
    // type verification
    if (!is_int($num)) return '';

    // boundary check
    if ($num <= 0) return '';


    if ((10 < ($num % 100)) && (($num % 100) < 20)) {
        return $num.'th';
    } else {
        switch ($num % 10) {
            case 1:
                return $num.'st';

            case 2:
                return $num.'nd';

            case 3:
                return $num.'rd';

            default:
                return $num.'th';
        }
    }

}//end add_ordinal_suffix()


function add_reverse_ordinal_suffix($num)
{
    return ($num == 1) ? '' : add_ordinal_suffix($num);

}//end add_reverse_ordinal_suffix()

             
function check_char_encoding($string, $string_encoding = NULL)
{   
    $string_encoding = $string_encoding ? $string_encoding : SQ_CONF_DEFAULT_CHARACTER_SET;

    if (!extension_loaded('mbstring') || !SQ_CONF_DEFAULT_CHARACTER_SET) {
        return $string;
    }
    
    return mb_convert_encoding($string, $string_encoding, $string_encoding);

}//end check_char_encoding()


function _cmp_dsort($str1, $str2) 
{
    return strlen($str2) > strlen($str1);
}


function _cmp_asort($str1, $str2) 
{
    return strlen($str1) > strlen($str2);
}

function array_sort_by_length(&$array, $sort_order=TRUE, $value_sort=TRUE)
{   
    $cmp_function = $sort_order ? '_cmp_asort' : '_cmp_dsort';
    $sort_function = $value_sort ? 'uasort' : 'uksort';

    return $sort_function($array, $cmp_function);
}



function get_unique_token()
    {
    if(isset($_SESSION['SQ_SYSTEM_NONCE_SECURITY_TOKEN'])) {
        return $_SESSION['SQ_SYSTEM_NONCE_SECURITY_TOKEN'];
    }
    
    $prefix      = '';
    $moreEntropy = TRUE;
    $token       = sha1(uniqid($prefix, $moreEntropy));

    $_SESSION['SQ_SYSTEM_NONCE_SECURITY_TOKEN'] = $token;
    
    return $token;

    }//end get_unique_token()


function xml_to_array($xml) 
{
    return @_xml_to_array_helper(new SimpleXmlIterator($xml, null));

}//end xml_to_array()


function _xml_to_array_helper($iter) 
{
    foreach($iter as $key=>$val) {
        $arr[$key][] = ($iter->hasChildren()) ? call_user_func (__FUNCTION__, $val) : strval($val);
    }
    
    return $arr;

}//end xml_to_array_helper()


function json_decode_array($data)
{
    if (!function_exists('json_decode')) {
        require_once 'Services/JSON.php';
        $json = new Services_JSON(SERVICES_JSON_LOOSE_TYPE);
        $output = $json->decode($data);
    } else {
        $output = json_decode($data, TRUE);
    }//end else
    return $output;
}//end json_decode_array()
            
?>