source: extensions/rv_akismet/akismet.class.php @ 24623

<?php
/**
 * 01.07.2008 22:32:28est
 *
 * Akismet PHP4 class
 *
 * <b>Usage</b>
 * <code>
 *    $comment = array(
 *           'author'    => 'viagra-test-123',
 *           'email'     => 'test@example.com',
 *           'website'   => 'http://www.example.com/',
 *           'body'      => 'This is a test comment',
 *           'permalink' => 'http://yourdomain.com/yourblogpost.url',
 *        );
 *
 *    $akismet = new Akismet('http://www.yourdomain.com/', 'YOUR_WORDPRESS_API_KEY', $comment);
 *
 *    if($akismet->errorsExist()) {
 *        echo"Couldn't connected to Akismet server!";
 *    } else {
 *        if($akismet->isSpam()) {
 *            echo"Spam detected";
 *        } else {
 *            echo"yay, no spam!";
 *        }
 *    }
 * </code>
 *
 * @author Bret Kuhns {@link www.miphp.net}
 * @link http://www.miphp.net/blog/view/new_akismet_class/
 * @version 0.3.4
 * @license http://www.opensource.org/licenses/mit-license.php MIT License
 */



// Error constants
define("AKISMET_SERVER_NOT_FOUND",  0);
define("AKISMET_RESPONSE_FAILED", 1);
define("AKISMET_INVALID_KEY",   2);



// Base class to assist in error handling between Akismet classes
class AkismetObject {
  var $errors = array();


  /**
   * Add a new error to the errors array in the object
   *
   * @param String  $name A name (array key) for the error
   * @param String  $string The error message
   * @return void
   */
  // Set an error in the object
  function setError($name, $message) {
    $this->errors[$name] = $message;
  }


  /**
   * Return a specific error message from the errors array
   *
   * @param String  $name The name of the error you want
   * @return mixed  Returns a String if the error exists, a false boolean if it does not exist
   */
  function getError($name) {
    if($this->isError($name)) {
      return $this->errors[$name];
    } else {
      return false;
    }
  }


  /**
   * Return all errors in the object
   *
   * @return String[]
   */
  function getErrors() {
    return (array)$this->errors;
  }


  /**
   * Check if a certain error exists
   *
   * @param String  $name The name of the error you want
   * @return boolean
   */
  function isError($name) {
    return isset($this->errors[$name]);
  }


  /**
   * Check if any errors exist
   *
   * @return boolean
   */
  function errorsExist() {
    return (count($this->errors) > 0);
  }


}





// Used by the Akismet class to communicate with the Akismet service
class AkismetHttpClient extends AkismetObject {
  var $akismetVersion = '1.1';
  var $con;
  var $host;
  var $port;
  var $apiKey;
  var $blogUrl;
  var $errors = array();


  // Constructor
  function AkismetHttpClient($host, $blogUrl, $apiKey, $port = 80) {
    $this->host = $host;
    $this->port = $port;
    $this->blogUrl = $blogUrl;
    $this->apiKey = $apiKey;
  }


  // Use the connection active in $con to get a response from the server and return that response
  function getResponse($request, $path, $type = "post", $responseLength = 1160) {
    $this->_connect();

    if($this->con && !$this->isError(AKISMET_SERVER_NOT_FOUND)) {
      $request  =
          strToUpper($type)." /{$this->akismetVersion}/$path HTTP/1.0\r\n" .
          "Host: ".((!empty($this->apiKey)) ? $this->apiKey."." : null)."{$this->host}\r\n" .
          "Content-Type: application/x-www-form-urlencoded; charset=utf-8\r\n" .
          "Content-Length: ".strlen($request)."\r\n" .
          "User-Agent: Akismet PHP4 Class\r\n" .
          "\r\n" .
          $request
        ;
      $response = "";

      @fwrite($this->con, $request);

      while(!feof($this->con)) {
        $response .= @fgets($this->con, $responseLength);
      }

      $response = explode("\r\n\r\n", $response, 2);
      return $response[1];
    } else {
      $this->setError(AKISMET_RESPONSE_FAILED, "The response could not be retrieved.");
    }

    $this->_disconnect();
  }


  // Connect to the Akismet server and store that connection in the instance variable $con
  function _connect() {
    if(!($this->con = @fsockopen($this->host, $this->port))) {
      $this->setError(AKISMET_SERVER_NOT_FOUND, "Could not connect to akismet server.");
    }
  }


  // Close the connection to the Akismet server
  function _disconnect() {
    @fclose($this->con);
  }


}





// The controlling class. This is the ONLY class the user should instantiate in
// order to use the Akismet service!
class Akismet extends AkismetObject {
  var $apiPort = 80;
  var $akismetServer = 'rest.akismet.com';
  var $akismetVersion = '1.1';
  var $http;

  var $ignore = array(
      'HTTP_COOKIE',
      'HTTP_X_FORWARDED_FOR',
      'HTTP_X_FORWARDED_HOST',
      'HTTP_MAX_FORWARDS',
      'HTTP_X_FORWARDED_SERVER',
      'REDIRECT_STATUS',
      'SERVER_PORT',
      'PATH',
      'DOCUMENT_ROOT',
      'SERVER_ADMIN',
      'QUERY_STRING',
      'PHP_SELF',
      'argv'
    );

  var $blogUrl = "";
  var $apiKey  = "";
  var $comment = array();


  /**
   * Constructor
   *
   * Set instance variables, connect to Akismet, and check API key
   *
   * @param String  $blogUrl  The URL to your own blog
   * @param   String  $apiKey   Your wordpress API key
   * @param   String[]  $comment  A formatted comment array to be examined by the Akismet service
   * @return  Akismet
   */
  function Akismet($blogUrl, $apiKey, $comment = array()) {
    $this->blogUrl = $blogUrl;
    $this->apiKey  = $apiKey;
    $this->setComment($comment);

    // Connect to the Akismet server and populate errors if they exist
    $this->http = new AkismetHttpClient($this->akismetServer, $blogUrl, $apiKey);
    if($this->http->errorsExist()) {
      $this->errors = array_merge($this->errors, $this->http->getErrors());
    }

    // Check if the API key is valid
    if(!$this->_isValidApiKey($apiKey)) {
      $this->setError(AKISMET_INVALID_KEY, "Your Akismet API key is not valid.");
    }
  }


  /**
   * Query the Akismet and determine if the comment is spam or not
   *
   * @return  boolean
   */
  function isSpam() {
    $response = $this->http->getResponse($this->_getQueryString(), 'comment-check');

    return ($response == "true");
  }


  /**
   * Submit this comment as an unchecked spam to the Akismet server
   *
   * @return  void
   */
  function submitSpam() {
    $this->http->getResponse($this->_getQueryString(), 'submit-spam');
  }


  /**
   * Submit a false-positive comment as "ham" to the Akismet server
   *
   * @return  void
   */
  function submitHam() {
    $this->http->getResponse($this->_getQueryString(), 'submit-ham');
  }


  /**
   * Manually set the comment value of the instantiated object.
   *
   * @param Array $comment
   * @return  void
   */
  function setComment($comment) {
    $this->comment = $comment;
    if(!empty($comment)) {
      $this->_formatCommentArray();
      $this->_fillCommentValues();
    }
  }


  /**
   * Returns the current value of the object's comment array.
   *
   * @return  Array
   */
  function getComment() {
    return $this->comment;
  }


  /**
   * Check with the Akismet server to determine if the API key is valid
   *
   * @access  Protected
   * @param String  $key  The Wordpress API key passed from the constructor argument
   * @return  boolean
   */
  function _isValidApiKey($key) {
    $keyCheck = $this->http->getResponse("key=".$this->apiKey."&blog=".$this->blogUrl, 'verify-key');

    return ($keyCheck == "valid");
  }


  /**
   * Format the comment array in accordance to the Akismet API
   *
   * @access  Protected
   * @return  void
   */
  function _formatCommentArray() {
    $format = array(
        'type' => 'comment_type',
        'author' => 'comment_author',
        'email' => 'comment_author_email',
        'website' => 'comment_author_url',
        'body' => 'comment_content'
      );

    foreach($format as $short => $long) {
      if(isset($this->comment[$short])) {
        $this->comment[$long] = $this->comment[$short];
        unset($this->comment[$short]);
      }
    }
  }


  /**
   * Fill any values not provided by the developer with available values.
   *
   * @return  void
   */
  function _fillCommentValues() {
    if(!isset($this->comment['user_ip'])) {
      $this->comment['user_ip'] = ($_SERVER['REMOTE_ADDR'] != getenv('SERVER_ADDR')) ? $_SERVER['REMOTE_ADDR'] : getenv('HTTP_X_FORWARDED_FOR');
    }
    if(!isset($this->comment['user_agent'])) {
      $this->comment['user_agent'] = $_SERVER['HTTP_USER_AGENT'];
    }
    if(!isset($this->comment['referrer'])) {
      $this->comment['referrer'] = $_SERVER['HTTP_REFERER'];
    }
    if(!isset($this->comment['blog'])) {
      $this->comment['blog'] = $this->blogUrl;
    }
  }


  /**
   * Build a query string for use with HTTP requests
   *
   * @access  Protected
   * @return  String
   */
  function _getQueryString() {
    foreach($_SERVER as $key => $value) {
      if(!in_array($key, $this->ignore)) {
        if($key == 'REMOTE_ADDR') {
          $this->comment[$key] = $this->comment['user_ip'];
        } else {
          $this->comment[$key] = $value;
        }
      }
    }

    $query_string = '';

    foreach($this->comment as $key => $data) {
      $query_string .= $key . '=' . urlencode(stripslashes($data)) . '&';
    }

    return $query_string;
  }


}
?>