mollom.inc

<?php
define('SQ_MOLLOM_SPAM', 0);
define('SQ_MOLLOM_UNSURE', 1);
define('SQ_MOLLOM_HAM', 2);
define('SQ_MOLLOM_UNKNOWN', 3);
define('SQ_MOLLOM_INCORRECT_CAPTCHA', 4);

require_once SQ_DATA_PATH.'/private/conf/tools.inc';


class Mollom
{
    private static $allowedReverseProxyAddresses = array();


    private static $privateKey;


    private static $publicKey;


    private static $reverseProxy = false;


    private static $serverHost = 'xmlrpc.mollom.com';


    private static $serverList = array();


    private static $timeout = 10;


    private static $userAgent = 'MollomPHP/1.1.3';


    private static $version = '1.0';


    private static $session_expire_time = 30;

    public static $default_server_list = array('http://xmlrpc3.mollom.com', 'http://xmlrpc2.mollom.com', 'http://xmlrpc1.mollom.com');

    private function buildValue($value)
    {
        // get type
        $type = gettype($value);

        // build value
        switch ($type)
        {
            case 'string':
                // escape it, cause Mollom can't handle CDATA (no pun intended)
                $value = htmlspecialchars($value, ENT_QUOTES, 'ISO-8859-15');
                return '<value><string>'. $value .'</string></value>'."\n";

            case 'array':
                // init struct
                $struct = '<value>'."\n";
                $struct .= '    <struct>'."\n";

                // loop array
                foreach ($value as $key => $value) $struct .= str_replace("\n", '', '<member>'. "\n" .'<name>'. $key .'</name>'. self::buildValue($value) .'</member>') . "\n";

                $struct .= '    </struct>'."\n";
                $struct .= '</value>'."\n";

                // return
                return $struct;

            default:
                return '<value>'. $value .'</value>'."\n";
        }
    }


    public static function checkCaptcha($sessionId, $solution)
    {
        // redefine
        $sessionId = (string) $sessionId;
        $solution = (string) $solution;
        
        // set autor ip
        $authorIp = self::getIpAddress();

        // set parameters
        $parameters['session_id'] = $sessionId;
        $parameters['solution'] = $solution;
        if($authorIp != null) $parameters['author_ip'] = (string) $authorIp;

        // do the call
        $responseString = self::doCall('checkCaptcha', $parameters);
        // validate
        if(!isset($responseString->params->param->value->boolean)) throw new Exception('Invalid response in checkCapthca.');

        // return
        if((string) $responseString->params->param->value->boolean == '1') return true;

        // fallback
        return false;
    }


    public static function checkContent($sessionId = null, $postTitle = null, $postBody = null, $authorName = null, $authorUrl = null, $authorEmail = null, $authorOpenId = null, $authorId = null)
    {   
        // validate
        if($sessionId === null && $postTitle === null && $postBody === null && $authorName === null && $authorUrl === null && $authorEmail === null && $authorOpenId === null && $authorId === null) throw new Exception('Specify at least on argument');

        // init var
        $parameters = array();
        $aReturn = array();

        // add parameters
        if($sessionId !== null) $parameters['session_id'] = (string) $sessionId;
        if($postTitle !== null) $parameters['post_title'] = (string) $postTitle;
        if($postBody !== null) $parameters['post_body'] = (string) $postBody;
        if($authorName !== null) $parameters['author_name'] = (string) $authorName;
        if($authorUrl !== null) $parameters['author_url'] = (string) $authorUrl;
        if($authorEmail !== null) $parameters['author_mail'] = (string) $authorEmail;
        if($authorOpenId != null) $parameters['author_openid'] = (string) $authorOpenId;
        if($authorId != null) $parameters['author_id'] = (string) $authorId;

        // set autor ip
        $authorIp = self::getIpAddress();
        if($authorIp != null) $parameters['author_ip'] = (string) $authorIp;

        if (SQ_TOOL_MOLLOM_TEST_MODE) {
            $parameters['testing'] = TRUE;
        }

        // do the call
        $responseString = self::doCall('checkContent', $parameters);

        // validate
        if(!isset($responseString->params->param->value->struct->member)) throw new Exception('Invalid response in checkContent.');

        // loop parts
        foreach ($responseString->params->param->value->struct->member as $part)
        {
            // get key
            $key = $part->name;
            
            // get value
            switch ($part->name)
            {
                case 'spam':
                    $value = (string) $part->value->int;

                    switch($value)
                    {
                        case '0':
                            $aReturn['spam'] = 'unknown';
                        break;

                        case '1':
                            $aReturn['spam'] = 'ham';
                        break;

                        case '2':
                            $aReturn['spam'] = 'spam';
                        break;

                        case '3':
                            $aReturn['spam'] = 'unsure';
                        break;
                    }
                break;

                case 'quality':
                    $aReturn['quality'] = (float) $part->value->double;
                break;

                case 'session_id':
                    $aReturn['session_id'] = (string) $part->value->string;
                break;
            }
        }

        // return
        return $aReturn;
    }


    private static function doCall($method, $parameters = array(), $server = null, $counter = 0, $test_mode = true)
    {
        // count available servers
        $countServerList = count(self::$serverList);

        if($server === null && $countServerList == 0) throw new Exception('No servers found, populate the serverlist. See setServerList().');

        // redefine var
        $method = (string) $method;
        $parameters = (array) $parameters;

        // possible methods
        $aPossibleMethods = array('checkCaptcha', 'checkContent', 'getAudioCaptcha', 'getImageCaptcha', 'getServerList', 'getStatistics', 'sendFeedback', 'verifyKey');

        // check if method is valid
        if(!in_array($method, $aPossibleMethods)) throw new Exception('Invalid method. Only '. implode(', ', $aPossibleMethods) .' are possible methods.');

        // check if public key is set
        if(self::$publicKey === null) throw new Exception('Public key wasn\'t set.');

        // check if private key is set
        if(self::$privateKey === null) throw new Exception('Private key wasn\'t set.');

        // still null
        if($server === null) $server = self::$serverList[$counter];

        // cleanup server string
        $server = str_replace(array('http://', 'https://'), '', $server);

        // create timestamp
        $time = gmdate("Y-m-d\TH:i:s.\\0\\0\\0O", time());

        // create nonce
        $nonce = md5(time());

        // create has
        $hash = base64_encode(
                    pack("H*", sha1((str_pad(self::$privateKey, 64, chr(0x00)) ^ (str_repeat(chr(0x5c), 64))) .
                    pack("H*", sha1((str_pad(self::$privateKey, 64, chr(0x00)) ^ (str_repeat(chr(0x36), 64))) .
                    $time . ':'. $nonce .':'. self::$privateKey))))
                );

        // add parameters
        $parameters['public_key'] = self::$publicKey;
        $parameters['time'] = $time;
        $parameters['hash'] = $hash;
        $parameters['nonce'] = $nonce;


        // build request
        $requestBody = '<?xml version="1.0"?>' ."\n";
        $requestBody .= '<methodCall>' ."\n";
        $requestBody .= '   <methodName>mollom.'. $method .'</methodName>' ."\n";
        $requestBody .= '   <params>' ."\n";
        $requestBody .= '       <param>'."\n";
        $requestBody .= '           '. self::buildValue($parameters) ."\n";
        $requestBody .= '       </param>'."\n";
        $requestBody .= '   </params>' ."\n";
        $requestBody .= '</methodCall>' ."\n";

        $options = array(
                    'USERAGENT'      => self::$userAgent,
                    'HTTP_VERSION'   => CURL_HTTP_VERSION_1_0,
                    'POST'           => true,
                    'FOLLOWLOCATION' => true,
                    'HEADER'         => true,
                    'RETURNTRANSFER' => true,
                    'CONNECTTIMEOUT' => self::$timeout,
                    'TIMEOUT'        => self::$timeout,
                    'POSTFIELDS'     => $requestBody,
                );

        $details     = fetch_url($server.'/'.self::$version, $options);
        $response    = $details['response'];
        $errorNumber = $details['errornumber'];
        $errorString = $details['errorstring'];

        // validate response
        if($response === false || $errorNumber != 0)
        {
            // increment counter
            $counter++;

            // no servers left
            if($errorNumber == 28 && !isset(self::$serverList[$counter]) && $countServerList != 0) throw new Exception('No more servers available, try to increase the timeout.');

            // timeout
            elseif($errorNumber == 28 && isset(self::$serverList[$counter])) return self::doCall($method, $parameters, self::$serverList[$counter], $counter);

            // other error
            else throw new Exception('Something went wrong. Maybe the following message can be handy.<br />'. $errorString, $errorNumber);
        }

        // process response
        $parts = explode("\r\n\r\n", $response);

        // validate
        if(!isset($parts[0]) || !isset($parts[1])) throw new Exception('Invalid response in doCall.');

        // get headers
        $headers = $parts[0];

        // rebuild body
        array_shift($parts);
        $body = implode('', $parts);

        // validate header
        $aValidHeaders = array('HTTP/1.0 200', 'HTTP/1.1 200');
        if(!in_array(substr($headers, 0, 12), $aValidHeaders)) throw new Exception('Invalid headers.');

        // do some validation
        $responseXML = @simplexml_load_string($body);
        if($responseXML === false) throw new Exception('Invalid body.');

        if(isset($responseXML->fault))
        {
            $code = (isset($responseXML->fault->value->struct->member[0]->value->int)) ? (int) $responseXML->fault->value->struct->member[0]->value->int : 'unknown';
            $message = (isset($responseXML->fault->value->struct->member[1]->value->string)) ? (string) $responseXML->fault->value->struct->member[1]->value->string : 'unknown';

            // handle errors
            switch ($code)
            {
                // code 1200 (Server too busy)
                case 1200:
                    if(self::$serverList === null) self::getServerList();

                    // do call again
                    return self::doCall($method, $parameters, self::$serverList[$counter], $counter++);
                break;
                
                // code 1000 (Parse error or internal problem)
                case 1000:

                // code 1100 (Serverlist outdated)
                case 1100:

                default:
                    log_dump('Mollom Error '.$code .': '. $message);
                    return FALSE;
            }//end switch
        }

        // return
        return $responseXML;
    }


    public static function getAudioCaptcha($sessionId = null)
    {
        // init vars
        $aReturn = array();
        $parameters = array();

        // set autor ip
        $authorIp = self::getIpAddress();

        // set parameters
        if($sessionId != null) $parameters['session_id'] = (string) $sessionId;
        if($authorIp != null) $parameters['author_ip'] = (string) $authorIp;

        // do the call
        $responseString = self::doCall('getAudioCaptcha', $parameters);

        // validate
        if(!isset($responseString->params->param->value->struct->member)) throw new Exception('Invalid response in getAudioCaptcha.');

        // loop elements
        foreach ($responseString->params->param->value->struct->member as $part) $aReturn[(string) $part->name] = (string) $part->value->string;

        // add image html
        $aReturn['html'] = '<object type="audio/mpeg" data="'. $aReturn['url'] .'" width="50" height="16">'."\n"
                                ."\t".'<param name="autoplay" value="false" />'."\n"
                                ."\t".'<param name="controller" value="true" />'."\n"
                            .'</object>';

        // return
        return $aReturn;
    }


    public static function getImageCaptcha($sessionId = null)
    {
        // init vars
        $aReturn = array();
        $parameters = array();

        // set autor ip
        $authorIp = self::getIpAddress();

        // set parameters
        if($sessionId !== null) $parameters['session_id'] = (string) $sessionId;
        if($authorIp !== null) $parameters['author_ip'] = (string) $authorIp;

        // do the call
        $responseString = self::doCall('getImageCaptcha', $parameters);

        // validate
        if(!isset($responseString->params->param->value->struct->member)) throw new Exception('Invalid response in getImageCaptcha.');

        // loop elements
        foreach ($responseString->params->param->value->struct->member as $part) $aReturn[(string) $part->name] = (string) $part->value->string;

        // add image html
        $aReturn['html'] = '<img src="'. $aReturn['url'] .'" alt="Mollom CAPTCHA" />';

        // return
        return $aReturn;
    }


    public static function getIpAddress()
    {
        // pre check
        if(!isset($_SERVER['REMOTE_ADDR'])) return null;

        // get ip
        $ipAddress = $_SERVER['REMOTE_ADDR'];

        if(self::$reverseProxy)
        {
            if(isset($_SERVER['HTTP_X_FORWARDED_FOR']))
            {
                if(!empty(self::$allowedReverseProxyAddresses) && in_array($ipAddress, self::$allowedProxyAddresses, true))
                {
                    return array_pop(explode(',', $_SERVER['HTTP_X_FORWARDED_FOR']));
                }
            }

            // running in a cluster environment
            if(isset($_SERVER['HTTP_X_CLUSTER_CLIENT_IP'])) return $_SERVER['HTTP_X_CLUSTER_CLIENT_IP'];
        }

        // fallback
        return $ipAddress;
    }


    public static function getServerList($counter = 0)
    {   
        // Use default list of servers to get the server list from Mollom
        self::$serverList = self::$default_server_list;

        // do the call
        $responseString = self::doCall('getServerList', array(), self::$serverHost, $counter);

        // validate
        if(!isset($responseString->params->param->value->array->data->value)) throw new Exception('Invalid response in getServerList.');
        
        // Refresh the list
        self::$serverList = array();

        // loop servers and add them
        foreach ($responseString->params->param->value->array->data->value as $server) self::$serverList[] = (string) $server->string;

        if(count(self::$serverList) == 0) self::$serverList = self::$default_server_list; 

        // return
        return self::$serverList;
    }


    public static function getStatistics($type)
    {
        // possible types
        $aPossibleTypes = array('total_days', 'total_accepted', 'total_rejected', 'yesterday_accepted', 'yesterday_rejected', 'today_accepted', 'today_rejected');

        // redefine
        $type = (string) $type;

        // validate
        if(!in_array($type, $aPossibleTypes)) throw new Exception('Invalid type. Only '. implode(', ', $aPossibleTypes) .' are possible types.');

        // do the call
        $responseString = self::doCall('getStatistics', array('type' => $type));

        // validate
        if(!isset($responseString->params->param->value->int)) throw new Exception('Invalid response in getStatistics.');

        // return
        return (int) $responseString->params->param->value->int;
    }


    public static function sendFeedback($sessionId, $feedback)
    {
        // possible feedback
        $aPossibleFeedback = array('spam', 'profanity', 'low-quality', 'unwanted');

        // redefine
        $sessionId = (string) $sessionId;
        $feedback = (string) $feedback;

        // validate
        if(!in_array($feedback, $aPossibleFeedback)) throw new Exception('Invalid feedback. Only '. implode(', ', $aPossibleFeedback) .' are possible feedback-strings.');

        // build parameters
        $parameters['session_id'] = $sessionId;
        $parameters['feedback'] = $feedback;

        // do the call
        $responseString = self::doCall('sendFeedback', $parameters);

        // validate
        if(!isset($responseString->params->param->value->boolean)) throw new Exception('Invalid response in sendFeedback.');

        // return
        if((string) $responseString->params->param->value->boolean == 1) return true;

        // fallback
        return false;
    }


    public static function setAllowedReverseProxyAddresses($addresses)
    {
        // store allowed ip-addresses
        self::$allowedReverseProxyAddresses = (array) $addresses;

        // set reverse proxy
        self::$reverseProxy = (!empty($addresses)) ? true : false;
    }


    public static function setPrivateKey($key)
    {
        self::$privateKey = (string) $key;
    }


    public static function setPublicKey($key)
    {
        self::$publicKey = (string) $key;
    }


    public static function setServerList($servers)
    {
        // redefine
        $server = (array) $servers;

        // loop servers
        foreach ($servers as $server) self::$serverList[] = $server;
    }


    public static function setTimeOut($timeout)
    {
        // redefine
        $timeout = (int) $timeout;

        // validate
        if($timeout == 0) throw new Exception('Invalid timeout. Timeout shouldn\'t be 0.');

        // set property
        self::$timeout = $timeout;
    }


    public static function setUserAgent($newUserAgent)
    {
        self::$userAgent .=  ' '. (string) $newUserAgent;
    }


    public static function verifyKey()
    {
        // do the call
        $responseString = self::doCall('verifyKey');

        // validate
        if(!isset($responseString->params->param->value->boolean)) return false;

        // return
        if((string) $responseString->params->param->value->boolean == '1') return true;

        // fallback
        return false;
    }
    
    
    //--   MATRIX MOLLOM FUNCTIONS        --//
    
    
     public static function getContentTypes()
     {
        return Array(
                0 => "Post Title",
                1 => "Post Body",
                2 => "Author Name",
                3 => "Author URL",
                4 => "Author Mail",
                5 => "Author OpenId",
                6 => "Author Id",                   
            );
     }
     

    /* Set and loads all the required Mollom parameters
    *
    * @return boolean
    * @access private
    */  
    public static function loadMollom()
    {   
        if (!SQ_TOOL_MOLLOM_PUBLIC_KEY || !SQ_TOOL_MOLLOM_PRIVATE_KEY) {
            return FALSE;
        }
        
        self::setPublicKey(SQ_TOOL_MOLLOM_PUBLIC_KEY);
        self::setPrivateKey(SQ_TOOL_MOLLOM_PRIVATE_KEY);
        
        $server_list = Array();
        if (!empty($_SESSION['SQ_MOLLOM_SERVER_LIST'])) {
            $server_list = unserialize($_SESSION['SQ_MOLLOM_SERVER_LIST']);
            self::setServerList($server_list);          
        } else {        
            $server_list = self::getServerList();
            $_SESSION['SQ_MOLLOM_SERVER_LIST'] = serialize($server_list);
        }       
        
        return !empty($server_list);
    }
    

    public static function verifySubmission($assetid, $parameters)
    {
        // Whether to accept the submission if Mollom fails to respond expectedly
        $unknown_submission = SQ_TOOL_MOLLOM_ACCEPT_BYPASSED_SUBMISSION ? SQ_MOLLOM_HAM : SQ_MOLLOM_SPAM;

        try {
            self::refreshMollomSession($assetid);

            if (!self::loadMollom()) {
                // Cannot load Mollom client, hence cannot check the response for spam.
                return $unknown_submission;
            }

            if (self::checkCaptchaResponse($assetid)) {
                // Captcha check correct
                unset($_SESSION['SQ_MOLLOM_CAPTCHA_'.$assetid]);
                return SQ_MOLLOM_HAM;

            } else if (isset($_SESSION['SQ_MOLLOM_CAPTCHA_'.$assetid])) {
                return SQ_MOLLOM_INCORRECT_CAPTCHA;
            }

            $response = self::checkContent(
                                    null,
                                    isset($parameters[0]) ? $parameters[0] : null,
                                    isset($parameters[1]) ? $parameters[1] : null,
                                    isset($parameters[2]) ? $parameters[2] : null,
                                    isset($parameters[3]) ? $parameters[3] : null,
                                    isset($parameters[4]) ? $parameters[4] : null,
                                    isset($parameters[5]) ? $parameters[5] : null,
                                    isset($parameters[6]) ? $parameters[6] : null
                );

            if (empty($response)) {
                // No response from server, cannot check spam. Accept it anyway
                // Better accept a spam rather than reject a legit answer
                return $unknown_submission;
            }

            $spam_status    = array_get_index($response, 'spam', 'unknown');
            $quality        = array_get_index($response, 'quality', 0);
            $session_id     = array_get_index($response, 'session_id', '');

            switch ($spam_status) {

                case 'unsure':
                    $mollom_captcha = Array();
                    $image_captcha = self::getImageCaptcha($session_id);
                    $mollom_captcha['session_id'] = $session_id;
                    $mollom_captcha['image_url'] = array_get_index($image_captcha, 'url', '');
                    $mollom_captcha['session_time'] = time();

                    $_SESSION['SQ_MOLLOM_CAPTCHA_'.$assetid] = $mollom_captcha;
                    return SQ_MOLLOM_UNSURE;

                case 'spam':
                    // Reject the answer
                    return SQ_MOLLOM_SPAM;

                case 'ham':
                    // Its not a spam
                    return SQ_MOLLOM_HAM;
            }
        } catch (Exception $e) {
            $add_msg = SQ_TOOL_MOLLOM_ACCEPT_BYPASSED_SUBMISSION ? 'Submission accepted anyway.' : 'Submission not accepted.';
            trigger_error("Error occured when trying to verify the submission with the Mollom: ".$e->getMessage()."\n".$add_msg, E_USER_WARNING);
        }

        return $unknown_submission;

    }//end verifySubmission()


    //--   MOLLOM MATRIX KEYWORD REPLACEMENT FUNCTIONS        --//
    

    public static function getMollomCaptchaKeywordReplacement($assetid)
    {   
        self::refreshMollomSession($assetid);

        if (empty($_SESSION['SQ_MOLLOM_CAPTCHA_'.$assetid]['session_id'])) {
            return null;
        }
        
        $captcha = self::getMollomCaptchaImageKeywordReplacement($assetid).
                        self::getMollomCaptchaRegenLinkKeywordReplacement($assetid).
                        "<br />".self::getMollomCaptchaFieldKeywordReplacement($assetid);

        return $captcha;
    }

    
    public static function getMollomCaptchaFieldKeywordReplacement($assetid)
    {   
        self::refreshMollomSession($assetid);
        
        if (empty($_SESSION['SQ_MOLLOM_CAPTCHA_'.$assetid]['session_id']) || (empty($_SESSION['SQ_MOLLOM_CAPTCHA_'.$assetid]['image_url']))) {
            return '';
        }

        $name   = 'sq_mollom_captcha_'.$assetid.'_input';
        $width  = 7;
        $max    = 20;

        ob_start();
            text_box($name, '', $width, $max, FALSE, '');
            hidden_field($name.'_session', $_SESSION['SQ_MOLLOM_CAPTCHA_'.$assetid]['session_id']);
            $input_box = ob_get_contents();
        ob_end_clean();

        return $input_box;
    }


    public static function getMollomCaptchaRegenLinkKeywordReplacement($assetid, $regen_text='Regenerate security key')
    {
        self::refreshMollomSession($assetid);

        if (!empty($_SESSION['SQ_MOLLOM_CAPTCHA_'.$assetid]['session_id'])) {
            $image_id = 'sq_mollom_captcha_'.$assetid.'_image';
            $image_url = $_SESSION['SQ_MOLLOM_CAPTCHA_'.$assetid]['image_url'];

            return '<a href="#" onClick="var img=document.getElementById(\''.$image_id.'\'); img.src=\''.$image_url.'?SQ_MOLLOM_REGEN_PARAM=\'+Math.random(); return false;">'.$regen_text.'</a>';
        }

        return '';
    }

    
    public static function getMollomCaptchaAudioKeywordReplacement($assetid)
    {
        self::refreshMollomSession($assetid);
        
        if (!empty($_SESSION['SQ_MOLLOM_CAPTCHA_'.$assetid]['session_id'])) {
            if (empty($_SESSION['SQ_MOLLOM_CAPTCHA_'.$assetid]['audio_url'])) {
                if (!self::loadMollom()) {
                    return '';
                }
                $audio_captcha = self::getAudioCaptcha($_SESSION['SQ_MOLLOM_CAPTCHA_'.$assetid]['session_id']);
                $_SESSION['SQ_MOLLOM_CAPTCHA_'.$assetid]['audio_url'] = $audio_captcha['url'];
            }

            return '<object type="audio/mpeg" data="'.$_SESSION['SQ_MOLLOM_CAPTCHA_'.$assetid]['audio_url'].'" width="50" height="16">'."\n"
                        ."\t".'<param name="autoplay" value="false" />'."\n"
                        ."\t".'<param name="controller" value="true" />'."\n"
                    .'</object>';
        }

        return '';
    }


    public static function getMollomCaptchaImageKeywordReplacement($assetid)
    {
        self::refreshMollomSession($assetid);
            
        if (!empty($_SESSION['SQ_MOLLOM_CAPTCHA_'.$assetid]['image_url'])) {
            $image_id = 'sq_mollom_captcha_'.$assetid.'_image';
            return '<img id="'.$image_id.'" src="'.$_SESSION['SQ_MOLLOM_CAPTCHA_'.$assetid]['image_url'].'" alt="CAPTCHA Image" />';
        }

        return '';
    }


    public static function checkCaptchaResponse($assetid)
    {
        if (!self::loadMollom()) {
            return FALSE;
        }

        $name = 'sq_mollom_captcha_'.$assetid.'_input';
        $captcha_solution = array_get_index($_POST, $name, '');
        $captcha_session_id = array_get_index($_POST, $name.'_session', '');
        
        if (empty($captcha_session_id) || empty($captcha_solution)) {
            return FALSE;
        }
        
        return self::checkCaptcha($captcha_session_id, $captcha_solution);
    }

    
    public static function refreshMollomSession($assetid)
    {
        if (isset($_SESSION['SQ_MOLLOM_CAPTCHA_'.$assetid]['session_id'])) {
            
            $session_time = array_get_index($_SESSION['SQ_MOLLOM_CAPTCHA_'.$assetid], 'session_time', 0);
            $current_time = time();
            if (($current_time - $session_time) > (60 * self::$session_expire_time)) {
                unset($_SESSION['SQ_MOLLOM_CAPTCHA_'.$assetid]);
            }
        }
    }
    

}//end class Mollom

?>