2004-12-15 21:57:05 -05:00
< ? php
2008-01-04 15:03:42 -05:00
/**
* Manages WordPress comments
*
* @ package WordPress
2008-08-04 18:29:37 -04:00
* @ subpackage Comment
2008-01-04 15:03:42 -05:00
*/
/**
2008-06-15 05:34:00 -04:00
* Checks whether a comment passes internal checks to be allowed to add .
2008-01-04 15:03:42 -05:00
*
2008-06-15 05:34:00 -04:00
* If comment moderation is set in the administration , then all comments ,
2008-09-21 23:39:41 -04:00
* regardless of their type and whitelist will be set to false . If the number of
* links exceeds the amount in the administration , then the check fails . If any
* of the parameter contents match the blacklist of words , then the check fails .
2008-06-15 05:34:00 -04:00
*
2008-09-22 16:21:10 -04:00
* If the number of links exceeds the amount in the administration , then the
* check fails . If any of the parameter contents match the blacklist of words ,
* then the check fails .
*
2008-06-15 05:34:00 -04:00
* If the comment is a trackback and part of the blogroll , then the trackback is
* automatically whitelisted . If the comment author was approved before , then
* the comment is automatically whitelisted .
*
* If none of the checks fail , then the failback is to set the check to pass
* ( return true ) .
2008-01-04 15:03:42 -05:00
*
2008-09-21 23:39:41 -04:00
* @ since 1.2 . 0
2008-01-04 15:03:42 -05:00
* @ uses $wpdb
*
2008-06-15 05:34:00 -04:00
* @ param string $author Comment Author ' s name
* @ param string $email Comment Author ' s email
* @ param string $url Comment Author ' s URL
* @ param string $comment Comment contents
* @ param string $user_ip Comment Author ' s IP address
* @ param string $user_agent Comment Author ' s User Agent
* @ param string $comment_type Comment type , either user submitted comment ,
* trackback , or pingback
* @ return bool Whether the checks passed ( true ) and the comments should be
* displayed or set to moderated
2008-01-04 15:03:42 -05:00
*/
2006-04-18 22:32:12 -04:00
function check_comment ( $author , $email , $url , $comment , $user_ip , $user_agent , $comment_type ) {
global $wpdb ;
2006-02-12 02:53:23 -05:00
2006-12-06 22:57:23 -05:00
if ( 1 == get_option ( 'comment_moderation' ) )
return false ; // If moderation is set to manual
2005-09-19 23:17:43 -04:00
2008-09-06 01:59:56 -04:00
if ( get_option ( 'comment_max_links' ) && preg_match_all ( " |(href \t *?= \t *?[' \" ]?)?(https?:)?//|i " , $comment , $out ) >= get_option ( 'comment_max_links' ) )
2006-04-18 22:32:12 -04:00
return false ; // Check # of external links
2005-09-19 23:17:43 -04:00
2006-12-06 22:57:23 -05:00
$mod_keys = trim ( get_option ( 'moderation_keys' ));
2006-04-18 22:32:12 -04:00
if ( ! empty ( $mod_keys ) ) {
$words = explode ( " \n " , $mod_keys );
2005-09-19 23:17:43 -04:00
2008-08-06 16:31:54 -04:00
foreach ( ( array ) $words as $word ) {
2006-04-18 22:32:12 -04:00
$word = trim ( $word );
2005-09-19 23:17:43 -04:00
2006-04-18 22:32:12 -04:00
// Skip empty lines
2006-12-06 22:57:23 -05:00
if ( empty ( $word ) )
continue ;
2005-09-19 23:17:43 -04:00
2006-11-19 02:56:05 -05:00
// Do some escaping magic so that '#' chars in the
2006-04-18 22:32:12 -04:00
// spam words don't break things:
$word = preg_quote ( $word , '#' );
2005-11-10 18:31:58 -05:00
2006-11-19 02:56:05 -05:00
$pattern = " # $word #i " ;
2006-04-18 22:32:12 -04:00
if ( preg_match ( $pattern , $author ) ) return false ;
if ( preg_match ( $pattern , $email ) ) return false ;
if ( preg_match ( $pattern , $url ) ) return false ;
if ( preg_match ( $pattern , $comment ) ) return false ;
if ( preg_match ( $pattern , $user_ip ) ) return false ;
if ( preg_match ( $pattern , $user_agent ) ) return false ;
}
}
2005-11-10 18:31:58 -05:00
2006-04-18 22:32:12 -04:00
// Comment whitelisting:
2006-08-30 17:46:31 -04:00
if ( 1 == get_option ( 'comment_whitelist' )) {
2006-04-18 22:32:12 -04:00
if ( 'trackback' == $comment_type || 'pingback' == $comment_type ) { // check if domain is in blogroll
$uri = parse_url ( $url );
$domain = $uri [ 'host' ];
$uri = parse_url ( get_option ( 'home' ) );
$home_domain = $uri [ 'host' ];
2007-09-27 03:34:15 -04:00
if ( $wpdb -> get_var ( $wpdb -> prepare ( " SELECT link_id FROM $wpdb->links WHERE link_url LIKE (%s) LIMIT 1 " , '%' . $domain . '%' )) || $domain == $home_domain )
2006-04-18 22:32:12 -04:00
return true ;
else
return false ;
2006-12-06 22:57:23 -05:00
} elseif ( $author != '' && $email != '' ) {
2007-09-27 03:34:15 -04:00
// expected_slashed ($author, $email)
2006-04-18 22:32:12 -04:00
$ok_to_comment = $wpdb -> get_var ( " SELECT comment_approved FROM $wpdb->comments WHERE comment_author = ' $author ' AND comment_author_email = ' $email ' and comment_approved = '1' LIMIT 1 " );
if ( ( 1 == $ok_to_comment ) &&
( empty ( $mod_keys ) || false === strpos ( $email , $mod_keys ) ) )
return true ;
else
return false ;
} else {
return false ;
}
2005-09-19 23:17:43 -04:00
}
2006-04-18 22:32:12 -04:00
return true ;
2005-09-19 23:17:43 -04:00
}
2008-01-04 15:03:42 -05:00
/**
2008-06-15 05:34:00 -04:00
* Retrieve the approved comments for post $post_id .
2008-01-04 15:03:42 -05:00
*
2008-09-21 23:39:41 -04:00
* @ since 2.0 . 0
2008-01-04 15:03:42 -05:00
* @ uses $wpdb
*
* @ param int $post_id The ID of the post
* @ return array $comments The approved comments
*/
2006-04-18 22:32:12 -04:00
function get_approved_comments ( $post_id ) {
2005-09-19 23:17:43 -04:00
global $wpdb ;
2007-09-27 03:34:15 -04:00
return $wpdb -> get_results ( $wpdb -> prepare ( " SELECT * FROM $wpdb->comments WHERE comment_post_ID = %d AND comment_approved = '1' ORDER BY comment_date " , $post_id ));
2006-04-18 22:32:12 -04:00
}
2005-09-19 23:17:43 -04:00
2008-01-04 15:03:42 -05:00
/**
2008-06-15 05:34:00 -04:00
* Retrieves comment data given a comment ID or comment object .
2008-01-04 15:03:42 -05:00
*
2008-06-15 05:34:00 -04:00
* If an object is passed then the comment data will be cached and then returned
2008-09-21 23:39:41 -04:00
* after being passed through a filter . If the comment is empty , then the global
* comment variable will be used , if it is set .
2008-06-15 05:34:00 -04:00
*
2008-09-22 16:21:10 -04:00
* If the comment is empty , then the global comment variable will be used , if it
* is set .
*
2008-09-21 23:39:41 -04:00
* @ since 2.0 . 0
2008-01-04 15:03:42 -05:00
* @ uses $wpdb
*
2008-06-15 05:34:00 -04:00
* @ param object | string | int $comment Comment to retrieve .
2008-09-21 23:39:41 -04:00
* @ param string $output Optional . OBJECT or ARRAY_A or ARRAY_N constants .
2008-01-04 15:03:42 -05:00
* @ return object | array | null Depends on $output value .
*/
2006-04-18 22:32:12 -04:00
function & get_comment ( & $comment , $output = OBJECT ) {
2007-06-07 20:20:22 -04:00
global $wpdb ;
2005-09-19 23:17:43 -04:00
2007-04-26 23:51:36 -04:00
if ( empty ( $comment ) ) {
if ( isset ( $GLOBALS [ 'comment' ]) )
$_comment = & $GLOBALS [ 'comment' ];
else
$_comment = null ;
} elseif ( is_object ( $comment ) ) {
2007-06-07 20:20:22 -04:00
wp_cache_add ( $comment -> comment_ID , $comment , 'comment' );
$_comment = $comment ;
2006-04-18 22:32:12 -04:00
} else {
2007-04-27 00:34:44 -04:00
if ( isset ( $GLOBALS [ 'comment' ]) && ( $GLOBALS [ 'comment' ] -> comment_ID == $comment ) ) {
2007-04-26 23:51:36 -04:00
$_comment = & $GLOBALS [ 'comment' ];
2007-06-07 20:20:22 -04:00
} elseif ( ! $_comment = wp_cache_get ( $comment , 'comment' ) ) {
2007-09-27 03:34:15 -04:00
$_comment = $wpdb -> get_row ( $wpdb -> prepare ( " SELECT * FROM $wpdb->comments WHERE comment_ID = %d LIMIT 1 " , $comment ));
2007-06-07 20:20:22 -04:00
wp_cache_add ( $_comment -> comment_ID , $_comment , 'comment' );
2006-04-18 22:32:12 -04:00
}
}
2005-11-16 01:29:36 -05:00
2007-06-07 20:20:22 -04:00
$_comment = apply_filters ( 'get_comment' , $_comment );
2006-04-18 22:32:12 -04:00
if ( $output == OBJECT ) {
return $_comment ;
} elseif ( $output == ARRAY_A ) {
2008-11-03 01:44:48 -05:00
$__comment = get_object_vars ( $_comment );
return $__comment ;
2006-04-18 22:32:12 -04:00
} elseif ( $output == ARRAY_N ) {
2008-11-03 01:44:48 -05:00
$__comment = array_values ( get_object_vars ( $_comment ));
return $__comment ;
2006-04-18 22:32:12 -04:00
} else {
return $_comment ;
2005-11-21 22:45:40 -05:00
}
2005-09-19 23:17:43 -04:00
}
2008-01-04 15:03:42 -05:00
/**
2008-09-21 23:39:41 -04:00
* Retrieve a list of comments .
2008-01-04 15:03:42 -05:00
*
2008-09-21 23:39:41 -04:00
* The list of comment arguments are 'status' , 'orderby' , 'comment_date_gmt' ,
* 'order' , 'number' , 'offset' , and 'post_id' .
2008-01-04 15:03:42 -05:00
*
2008-09-21 23:39:41 -04:00
* @ since 2.7 . 0
2008-08-04 18:29:37 -04:00
* @ uses $wpdb
2008-01-04 15:03:42 -05:00
*
2008-09-21 23:39:41 -04:00
* @ param mixed $args Optional . Array or string of options to override defaults .
* @ return array List of comments .
2008-01-04 15:03:42 -05:00
*/
2008-08-04 18:29:37 -04:00
function get_comments ( $args = '' ) {
global $wpdb ;
$defaults = array ( 'status' => '' , 'orderby' => 'comment_date_gmt' , 'order' => 'DESC' , 'number' => '' , 'offset' => '' , 'post_id' => 0 );
$r = wp_parse_args ( $args , $defaults );
extract ( $r , EXTR_SKIP );
$post_id = absint ( $post_id );
if ( 'hold' == $status )
$approved = " comment_approved = '0' " ;
elseif ( 'approve' == $status )
$approved = " comment_approved = '1' " ;
elseif ( 'spam' == $status )
$approved = " comment_approved = 'spam' " ;
else
$approved = " ( comment_approved = '0' OR comment_approved = '1' ) " ;
2008-10-28 03:29:04 -04:00
$order = ( 'ASC' == $order ) ? 'ASC' : 'DESC' ;
2008-08-04 18:29:37 -04:00
$orderby = 'comment_date_gmt' ; // Hard code for now
$number = absint ( $number );
$offset = absint ( $offset );
if ( ! empty ( $number ) ) {
if ( $offset )
$number = 'LIMIT ' . $offset . ',' . $number ;
else
$number = 'LIMIT ' . $number ;
2006-04-18 22:32:12 -04:00
} else {
2008-08-04 18:29:37 -04:00
$number = '' ;
2006-04-18 22:32:12 -04:00
}
2008-08-04 18:29:37 -04:00
if ( ! empty ( $post_id ) )
$post_where = " comment_post_ID = $post_id AND " ;
else
$post_where = '' ;
2008-09-05 11:43:26 -04:00
return $wpdb -> get_results ( " SELECT * FROM $wpdb->comments WHERE $post_where $approved ORDER BY $orderby $order $number " );
2008-08-04 18:29:37 -04:00
}
/**
* Retrieve all of the WordPress supported comment statuses .
*
2008-09-21 23:39:41 -04:00
* Comments have a limited set of valid status values , this provides the comment
* status values and descriptions .
2008-08-04 18:29:37 -04:00
*
* @ package WordPress
* @ subpackage Post
2008-09-21 23:39:41 -04:00
* @ since 2.7 . 0
2008-08-04 18:29:37 -04:00
*
* @ return array List of comment statuses .
*/
function get_comment_statuses ( ) {
$status = array (
'hold' => __ ( 'Unapproved' ),
'approve' => __ ( 'Approved' ),
'spam' => __ ( 'Spam' ),
);
return $status ;
2006-04-18 22:32:12 -04:00
}
2008-08-04 18:29:37 -04:00
2008-01-04 15:03:42 -05:00
/**
2008-06-15 05:34:00 -04:00
* The date the last comment was modified .
2008-01-04 15:03:42 -05:00
*
* @ since 1.5 . 0
* @ uses $wpdb
* @ global array $cache_lastcommentmodified
*
2008-06-15 05:34:00 -04:00
* @ param string $timezone Which timezone to use in reference to 'gmt' , 'blog' ,
2008-09-21 23:39:41 -04:00
* or 'server' locations .
* @ return string Last comment modified date .
2008-01-04 15:03:42 -05:00
*/
2006-04-18 22:32:12 -04:00
function get_lastcommentmodified ( $timezone = 'server' ) {
2007-12-06 14:49:33 -05:00
global $cache_lastcommentmodified , $wpdb ;
2008-01-14 00:59:39 -05:00
if ( isset ( $cache_lastcommentmodified [ $timezone ]) )
return $cache_lastcommentmodified [ $timezone ];
2006-04-18 22:32:12 -04:00
$add_seconds_server = date ( 'Z' );
2008-01-14 00:59:39 -05:00
switch ( strtolower ( $timezone )) {
case 'gmt' :
2008-02-05 18:29:59 -05:00
$lastcommentmodified = $wpdb -> get_var ( " SELECT comment_date_gmt FROM $wpdb->comments WHERE comment_approved = '1' ORDER BY comment_date_gmt DESC LIMIT 1 " );
2008-01-14 00:59:39 -05:00
break ;
case 'blog' :
2008-02-05 18:29:59 -05:00
$lastcommentmodified = $wpdb -> get_var ( " SELECT comment_date FROM $wpdb->comments WHERE comment_approved = '1' ORDER BY comment_date_gmt DESC LIMIT 1 " );
2008-01-14 00:59:39 -05:00
break ;
case 'server' :
$lastcommentmodified = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT DATE_ADD(comment_date_gmt, INTERVAL %s SECOND) FROM $wpdb->comments WHERE comment_approved = '1' ORDER BY comment_date_gmt DESC LIMIT 1 " , $add_seconds_server ));
break ;
2006-04-18 22:32:12 -04:00
}
2008-01-14 00:59:39 -05:00
$cache_lastcommentmodified [ $timezone ] = $lastcommentmodified ;
2006-04-18 22:32:12 -04:00
return $lastcommentmodified ;
2005-09-19 23:17:43 -04:00
}
2008-01-04 15:03:42 -05:00
/**
2008-06-15 05:34:00 -04:00
* The amount of comments in a post or total comments .
2008-01-04 15:03:42 -05:00
*
2008-09-21 23:39:41 -04:00
* A lot like { @ link wp_count_comments ()}, in that they both return comment
* stats ( albeit with different types ) . The { @ link wp_count_comments ()} actual
* caches , but this function does not .
2008-01-04 15:03:42 -05:00
*
* @ since 2.0 . 0
* @ uses $wpdb
*
2008-09-21 23:39:41 -04:00
* @ param int $post_id Optional . Comment amount in post if > 0 , else total comments blog wide .
* @ return array The amount of spam , approved , awaiting moderation , and total comments .
2008-01-04 15:03:42 -05:00
*/
2008-01-01 13:40:39 -05:00
function get_comment_count ( $post_id = 0 ) {
2008-01-04 15:03:42 -05:00
global $wpdb ;
$post_id = ( int ) $post_id ;
$where = '' ;
if ( $post_id > 0 ) {
2008-04-14 12:13:25 -04:00
$where = $wpdb -> prepare ( " WHERE comment_post_ID = %d " , $post_id );
2008-01-04 15:03:42 -05:00
}
2008-02-05 01:47:27 -05:00
$totals = ( array ) $wpdb -> get_results ( "
SELECT comment_approved , COUNT ( * ) AS total
FROM { $wpdb -> comments }
{ $where }
GROUP BY comment_approved
2008-01-04 15:03:42 -05:00
" , ARRAY_A);
2008-02-05 01:47:27 -05:00
$comment_count = array (
" approved " => 0 ,
2008-01-04 15:03:42 -05:00
" awaiting_moderation " => 0 ,
" spam " => 0 ,
" total_comments " => 0
2008-02-05 01:47:27 -05:00
);
2008-01-04 15:03:42 -05:00
2008-02-05 01:47:27 -05:00
foreach ( $totals as $row ) {
switch ( $row [ 'comment_approved' ] ) {
case 'spam' :
$comment_count [ 'spam' ] = $row [ 'total' ];
2008-01-04 15:03:42 -05:00
$comment_count [ " total_comments " ] += $row [ 'total' ];
2008-02-05 01:47:27 -05:00
break ;
case 1 :
$comment_count [ 'approved' ] = $row [ 'total' ];
2008-01-04 15:03:42 -05:00
$comment_count [ 'total_comments' ] += $row [ 'total' ];
2008-02-05 01:47:27 -05:00
break ;
2008-01-04 15:03:42 -05:00
case 0 :
$comment_count [ 'awaiting_moderation' ] = $row [ 'total' ];
$comment_count [ 'total_comments' ] += $row [ 'total' ];
break ;
default :
break ;
}
}
2008-01-01 13:40:39 -05:00
2008-01-04 15:03:42 -05:00
return $comment_count ;
}
2008-01-01 13:40:39 -05:00
2008-01-04 15:03:42 -05:00
/**
2008-06-15 05:34:00 -04:00
* Sanitizes the cookies sent to the user already .
2008-01-04 15:03:42 -05:00
*
2008-06-15 05:34:00 -04:00
* Will only do anything if the cookies have already been created for the user .
* Mostly used after cookies had been sent to use elsewhere .
2008-01-04 15:03:42 -05:00
*
* @ since 2.0 . 4
*/
2006-06-22 16:52:12 -04:00
function sanitize_comment_cookies () {
if ( isset ( $_COOKIE [ 'comment_author_' . COOKIEHASH ]) ) {
$comment_author = apply_filters ( 'pre_comment_author_name' , $_COOKIE [ 'comment_author_' . COOKIEHASH ]);
$comment_author = stripslashes ( $comment_author );
2006-12-21 05:10:04 -05:00
$comment_author = attribute_escape ( $comment_author );
2006-06-22 16:52:12 -04:00
$_COOKIE [ 'comment_author_' . COOKIEHASH ] = $comment_author ;
}
if ( isset ( $_COOKIE [ 'comment_author_email_' . COOKIEHASH ]) ) {
$comment_author_email = apply_filters ( 'pre_comment_author_email' , $_COOKIE [ 'comment_author_email_' . COOKIEHASH ]);
$comment_author_email = stripslashes ( $comment_author_email );
2006-12-21 05:10:04 -05:00
$comment_author_email = attribute_escape ( $comment_author_email );
2006-06-22 16:52:12 -04:00
$_COOKIE [ 'comment_author_email_' . COOKIEHASH ] = $comment_author_email ;
}
if ( isset ( $_COOKIE [ 'comment_author_url_' . COOKIEHASH ]) ) {
$comment_author_url = apply_filters ( 'pre_comment_author_url' , $_COOKIE [ 'comment_author_url_' . COOKIEHASH ]);
$comment_author_url = stripslashes ( $comment_author_url );
$_COOKIE [ 'comment_author_url_' . COOKIEHASH ] = $comment_author_url ;
}
}
2008-01-04 15:03:42 -05:00
/**
2008-06-15 05:34:00 -04:00
* Validates whether this comment is allowed to be made or not .
2008-01-04 15:03:42 -05:00
*
* @ since 2.0 . 0
* @ uses $wpdb
* @ uses apply_filters () Calls 'pre_comment_approved' hook on the type of comment
* @ uses do_action () Calls 'check_comment_flood' hook on $comment_author_IP , $comment_author_email , and $comment_date_gmt
*
* @ param array $commentdata Contains information on the comment
* @ return mixed Signifies the approval status ( 0 | 1 | 'spam' )
*/
2005-09-19 23:17:43 -04:00
function wp_allow_comment ( $commentdata ) {
global $wpdb ;
2007-06-14 18:45:40 -04:00
extract ( $commentdata , EXTR_SKIP );
2005-09-19 23:17:43 -04:00
// Simple duplicate check
2007-09-27 03:34:15 -04:00
// expected_slashed ($comment_post_ID, $comment_author, $comment_author_email, $comment_content)
2005-09-19 23:17:43 -04:00
$dupe = " SELECT comment_ID FROM $wpdb->comments WHERE comment_post_ID = ' $comment_post_ID ' AND ( comment_author = ' $comment_author ' " ;
if ( $comment_author_email )
$dupe .= " OR comment_author_email = ' $comment_author_email ' " ;
$dupe .= " ) AND comment_content = ' $comment_content ' LIMIT 1 " ;
2008-08-24 02:56:22 -04:00
if ( $wpdb -> get_var ( $dupe ) ) {
if ( defined ( 'DOING_AJAX' ) )
die ( __ ( 'Duplicate comment detected; it looks as though you\'ve already said that!' ) );
2006-07-05 18:00:03 -04:00
wp_die ( __ ( 'Duplicate comment detected; it looks as though you\'ve already said that!' ) );
2008-08-24 02:56:22 -04:00
}
2005-09-19 23:17:43 -04:00
2007-08-27 02:34:18 -04:00
do_action ( 'check_comment_flood' , $comment_author_IP , $comment_author_email , $comment_date_gmt );
2005-09-19 23:17:43 -04:00
if ( $user_id ) {
$userdata = get_userdata ( $user_id );
$user = new WP_User ( $user_id );
2007-09-27 03:34:15 -04:00
$post_author = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT post_author FROM $wpdb->posts WHERE ID = %d LIMIT 1 " , $comment_post_ID ));
2005-09-19 23:17:43 -04:00
}
2008-05-08 20:45:17 -04:00
if ( $userdata && ( $user_id == $post_author || $user -> has_cap ( 'moderate_comments' ) ) ) {
2006-12-06 22:57:23 -05:00
// The author and the admins get respect.
2005-09-19 23:17:43 -04:00
$approved = 1 ;
2006-12-06 22:57:23 -05:00
} else {
// Everyone else's comments will be checked.
2005-09-19 23:17:43 -04:00
if ( check_comment ( $comment_author , $comment_author_email , $comment_author_url , $comment_content , $comment_author_IP , $comment_agent , $comment_type ) )
$approved = 1 ;
else
$approved = 0 ;
if ( wp_blacklist_check ( $comment_author , $comment_author_email , $comment_author_url , $comment_content , $comment_author_IP , $comment_agent ) )
$approved = 'spam' ;
}
$approved = apply_filters ( 'pre_comment_approved' , $approved );
return $approved ;
}
2008-01-04 15:03:42 -05:00
/**
2008-09-21 23:39:41 -04:00
* Check whether comment flooding is occurring .
2008-01-04 15:03:42 -05:00
*
2008-09-21 23:39:41 -04:00
* Won ' t run , if current user can manage options , so to not block
* administrators .
2008-01-04 15:03:42 -05:00
*
* @ since 2.3 . 0
* @ uses $wpdb
2008-09-21 23:39:41 -04:00
* @ uses apply_filters () Calls 'comment_flood_filter' filter with first
* parameter false , last comment timestamp , new comment timestamp .
* @ uses do_action () Calls 'comment_flood_trigger' action with parameters with
* last comment timestamp and new comment timestamp .
*
* @ param string $ip Comment IP .
* @ param string $email Comment author email address .
* @ param string $date MySQL time string .
2008-01-04 15:03:42 -05:00
*/
2007-08-27 02:34:18 -04:00
function check_comment_flood_db ( $ip , $email , $date ) {
global $wpdb ;
2008-03-20 16:32:18 -04:00
if ( current_user_can ( 'manage_options' ) )
return ; // don't throttle admins
2008-04-14 12:13:25 -04:00
if ( $lasttime = $wpdb -> get_var ( $wpdb -> prepare ( " SELECT comment_date_gmt FROM $wpdb->comments WHERE comment_author_IP = %s OR comment_author_email = %s ORDER BY comment_date DESC LIMIT 1 " , $ip , $email ) ) ) {
2007-08-27 02:34:18 -04:00
$time_lastcomment = mysql2date ( 'U' , $lasttime );
$time_newcomment = mysql2date ( 'U' , $date );
$flood_die = apply_filters ( 'comment_flood_filter' , false , $time_lastcomment , $time_newcomment );
if ( $flood_die ) {
do_action ( 'comment_flood_trigger' , $time_lastcomment , $time_newcomment );
2008-08-24 02:56:22 -04:00
if ( defined ( 'DOING_AJAX' ) )
die ( __ ( 'You are posting comments too quickly. Slow down.' ) );
2008-10-24 17:00:40 -04:00
wp_die ( __ ( 'You are posting comments too quickly. Slow down.' ), '' , array ( 'response' => 403 ) );
2007-08-27 02:34:18 -04:00
}
}
}
2006-12-06 22:57:23 -05:00
2008-09-15 20:23:38 -04:00
/**
* Separates an array of comments into an array keyed by comment_type .
*
2008-09-21 23:39:41 -04:00
* @ since 2.7 . 0
2008-09-15 20:23:38 -04:00
*
* @ param array $comments Array of comments
* @ return array Array of comments keyed by comment_type .
*/
function & separate_comments ( & $comments ) {
$comments_by_type = array ( 'comment' => array (), 'trackback' => array (), 'pingback' => array (), 'pings' => array ());
$count = count ( $comments );
for ( $i = 0 ; $i < $count ; $i ++ ) {
$type = $comments [ $i ] -> comment_type ;
2008-09-30 15:49:26 -04:00
if ( empty ( $type ) )
$type = 'comment' ;
2008-09-15 20:23:38 -04:00
$comments_by_type [ $type ][] = & $comments [ $i ];
if ( 'trackback' == $type || 'pingback' == $type )
$comments_by_type [ 'pings' ][] = & $comments [ $i ];
}
return $comments_by_type ;
}
2008-10-23 12:08:47 -04:00
/**
* Calculate the total number of comment pages .
*
* @ since 2.7 . 0
2008-10-28 03:29:04 -04:00
* @ uses get_query_var () Used to fill in the default for $per_page parameter .
* @ uses get_option () Used to fill in defaults for parameters .
* @ uses Walker_Comment
2008-10-23 12:08:47 -04:00
*
* @ param array $comments Optional array of comment objects . Defaults to $wp_query -> comments
* @ param int $per_page Optional comments per page .
* @ param boolean $threaded Optional control over flat or threaded comments .
* @ return int Number of comment pages .
*/
function get_comment_pages_count ( $comments = null , $per_page = null , $threaded = null ) {
global $wp_query ;
if ( ! $comments || ! is_array ( $comments ) )
$comments = $wp_query -> comments ;
if ( empty ( $comments ) )
return 0 ;
if ( ! isset ( $per_page ) )
$per_page = ( int ) get_query_var ( 'comments_per_page' );
if ( 0 === $per_page )
$per_page = ( int ) get_option ( 'comments_per_page' );
if ( 0 === $per_page )
return 1 ;
if ( ! isset ( $threaded ) )
$threaded = get_option ( 'thread_comments' );
if ( $threaded ) {
$walker = new Walker_Comment ;
$count = ceil ( $walker -> get_number_of_root_elements ( $comments ) / $per_page );
} else {
$count = ceil ( count ( $comments ) / $per_page );
}
return $count ;
}
2008-10-27 12:31:26 -04:00
/**
* Calculate what page number a comment will appear on for comment paging .
*
* @ since 2.7 . 0
2008-10-28 03:29:04 -04:00
* @ uses get_comment () Gets the full comment of the $comment_ID parameter .
* @ uses get_option () Get various settings to control function and defaults .
* @ uses get_page_of_comment () Used to loop up to top level comment .
2008-10-27 12:31:26 -04:00
*
* @ param int $comment_ID Comment ID .
* @ param int $per_page Optional comments per page .
* @ return int | null Comment page number or null on error .
*/
function get_page_of_comment ( $comment_ID , $per_page = null , $threaded = null ) {
2008-10-28 03:29:04 -04:00
if ( ! $comment = get_comment ( $comment_ID ) )
2008-10-27 12:31:26 -04:00
return ;
if ( ! get_option ( 'page_comments' ) )
return 1 ;
if ( null === $per_page )
$per_page = get_option ( 'comments_per_page' );
if ( null === $threaded )
$threaded = get_option ( 'thread_comments' );
2008-10-28 03:17:29 -04:00
// Find this comment's top level parent if threading is enabled
2008-10-28 03:29:04 -04:00
if ( $threaded && 0 != $comment -> comment_parent )
return get_page_of_comment ( $comment -> comment_parent , $per_page , $threaded );
$comments = get_comments ( array ( 'post_id' => $comment -> comment_post_ID , 'order' => 'ASC' ) );
2008-10-27 12:31:26 -04:00
// Start going through the comments until we find what page number the above top level comment is on
$page = 1 ;
$comthispage = 0 ;
foreach ( $comments as $com ) {
if ( $threaded && 0 != $com -> comment_parent )
continue ;
if ( $com -> comment_ID == $comment -> comment_ID )
return $page ;
$comthispage ++ ;
if ( $comthispage >= $per_page ) {
$page ++ ;
$comthispage = 0 ;
}
}
}
2008-01-04 15:03:42 -05:00
/**
2008-06-15 05:34:00 -04:00
* Does comment contain blacklisted characters or words .
2008-01-04 15:03:42 -05:00
*
* @ since 1.5 . 0
2008-09-21 23:39:41 -04:00
* @ uses do_action () Calls 'wp_blacklist_check' hook for all parameters .
2008-01-04 15:03:42 -05:00
*
* @ param string $author The author of the comment
* @ param string $email The email of the comment
* @ param string $url The url used in the comment
* @ param string $comment The comment content
* @ param string $user_ip The comment author IP address
* @ param string $user_agent The author ' s browser user agent
* @ return bool True if comment contains blacklisted content , false if comment does not
*/
2006-06-07 19:17:59 -04:00
function wp_blacklist_check ( $author , $email , $url , $comment , $user_ip , $user_agent ) {
do_action ( 'wp_blacklist_check' , $author , $email , $url , $comment , $user_ip , $user_agent );
if ( preg_match_all ( '/&#(\d+);/' , $comment . $author . $url , $chars ) ) {
2006-12-06 22:57:23 -05:00
foreach ( ( array ) $chars [ 1 ] as $char ) {
2006-06-07 19:17:59 -04:00
// If it's an encoded char in the normal ASCII set, reject
if ( 38 == $char )
continue ; // Unless it's &
2006-12-06 22:57:23 -05:00
if ( $char < 128 )
2006-06-07 19:17:59 -04:00
return true ;
}
}
2006-08-30 17:46:31 -04:00
$mod_keys = trim ( get_option ( 'blacklist_keys' ) );
2006-12-06 22:57:23 -05:00
if ( '' == $mod_keys )
2006-06-07 19:17:59 -04:00
return false ; // If moderation keys are empty
$words = explode ( " \n " , $mod_keys );
2006-12-06 22:57:23 -05:00
foreach ( ( array ) $words as $word ) {
2006-06-07 19:17:59 -04:00
$word = trim ( $word );
// Skip empty lines
if ( empty ( $word ) ) { continue ; }
2006-11-19 02:56:05 -05:00
// Do some escaping magic so that '#' chars in the
2006-06-07 19:17:59 -04:00
// spam words don't break things:
$word = preg_quote ( $word , '#' );
2006-11-19 02:56:05 -05:00
$pattern = " # $word #i " ;
2006-12-06 22:57:23 -05:00
if (
preg_match ( $pattern , $author )
|| preg_match ( $pattern , $email )
|| preg_match ( $pattern , $url )
|| preg_match ( $pattern , $comment )
|| preg_match ( $pattern , $user_ip )
|| preg_match ( $pattern , $user_agent )
)
return true ;
2006-06-07 19:17:59 -04:00
}
return false ;
}
2008-06-15 05:34:00 -04:00
/**
2008-09-21 23:39:41 -04:00
* Retrieve total comments for blog or single post .
2008-06-15 05:34:00 -04:00
*
2008-09-21 23:39:41 -04:00
* The properties of the returned object contain the 'moderated' , 'approved' ,
* and spam comments for either the entire blog or single post . Those properties
* contain the amount of comments that match the status . The 'total_comments'
* property contains the integer of total comments .
2008-06-15 05:34:00 -04:00
*
2008-09-21 23:39:41 -04:00
* The comment stats are cached and then retrieved , if they already exist in the
* cache .
*
* @ since 2.5 . 0
*
* @ param int $post_id Optional . Post ID .
* @ return object Comment stats .
2008-06-15 05:34:00 -04:00
*/
2008-05-01 12:52:48 -04:00
function wp_count_comments ( $post_id = 0 ) {
2008-02-23 03:33:44 -05:00
global $wpdb ;
2008-05-01 12:52:48 -04:00
$post_id = ( int ) $post_id ;
2008-05-02 15:42:44 -04:00
$count = wp_cache_get ( " comments- { $post_id } " , 'counts' );
2008-04-16 19:45:39 -04:00
if ( false !== $count )
return $count ;
2008-05-01 12:52:48 -04:00
$where = '' ;
if ( $post_id > 0 )
$where = $wpdb -> prepare ( " WHERE comment_post_ID = %d " , $post_id );
$count = $wpdb -> get_results ( " SELECT comment_approved, COUNT( * ) AS num_comments FROM { $wpdb -> comments } { $where } GROUP BY comment_approved " , ARRAY_A );
2008-02-23 03:33:44 -05:00
2008-05-01 12:52:48 -04:00
$total = 0 ;
2008-02-23 03:33:44 -05:00
$stats = array ( );
$approved = array ( '0' => 'moderated' , '1' => 'approved' , 'spam' => 'spam' );
foreach ( ( array ) $count as $row_num => $row ) {
2008-05-01 12:52:48 -04:00
$total += $row [ 'num_comments' ];
2008-02-23 03:33:44 -05:00
$stats [ $approved [ $row [ 'comment_approved' ]]] = $row [ 'num_comments' ];
}
2008-05-01 12:52:48 -04:00
$stats [ 'total_comments' ] = $total ;
2008-02-23 03:33:44 -05:00
foreach ( $approved as $key ) {
if ( empty ( $stats [ $key ]) )
$stats [ $key ] = 0 ;
}
2008-04-16 19:45:39 -04:00
$stats = ( object ) $stats ;
2008-05-02 15:42:44 -04:00
wp_cache_set ( " comments- { $post_id } " , $stats , 'counts' );
2008-04-16 19:45:39 -04:00
return $stats ;
2008-02-23 03:33:44 -05:00
}
2008-01-04 15:03:42 -05:00
/**
2008-06-15 05:34:00 -04:00
* Removes comment ID and maybe updates post comment count .
2008-01-04 15:03:42 -05:00
*
2008-06-15 05:34:00 -04:00
* The post comment count will be updated if the comment was approved and has a
* post ID available .
2008-01-04 15:03:42 -05:00
*
* @ since 2.0 . 0
* @ uses $wpdb
* @ uses do_action () Calls 'delete_comment' hook on comment ID
* @ uses do_action () Calls 'wp_set_comment_status' hook on comment ID with 'delete' set for the second parameter
2008-10-16 00:18:45 -04:00
* @ uses wp_transition_comment_status () Passes new and old comment status along with $comment object
2008-01-04 15:03:42 -05:00
*
* @ param int $comment_id Comment ID
2008-09-22 16:21:10 -04:00
* @ return bool False if delete comment query failure , true on success .
2008-01-04 15:03:42 -05:00
*/
2005-11-16 01:29:36 -05:00
function wp_delete_comment ( $comment_id ) {
global $wpdb ;
do_action ( 'delete_comment' , $comment_id );
$comment = get_comment ( $comment_id );
2008-04-14 12:13:25 -04:00
if ( ! $wpdb -> query ( $wpdb -> prepare ( " DELETE FROM $wpdb->comments WHERE comment_ID = %d LIMIT 1 " , $comment_id ) ) )
2005-11-16 01:29:36 -05:00
return false ;
$post_id = $comment -> comment_post_ID ;
2005-12-05 00:31:27 -05:00
if ( $post_id && $comment -> comment_approved == 1 )
2006-06-19 13:17:52 -04:00
wp_update_comment_count ( $post_id );
2005-11-16 01:29:36 -05:00
2007-06-07 20:20:22 -04:00
clean_comment_cache ( $comment_id );
2005-11-16 01:29:36 -05:00
do_action ( 'wp_set_comment_status' , $comment_id , 'delete' );
2008-10-16 00:18:45 -04:00
wp_transition_comment_status ( 'delete' , $comment -> comment_approved , $comment );
2005-11-16 01:29:36 -05:00
return true ;
2005-09-19 23:17:43 -04:00
}
2008-01-04 15:03:42 -05:00
/**
2008-06-15 05:34:00 -04:00
* The status of a comment by ID .
2008-01-04 15:03:42 -05:00
*
* @ since 1.0 . 0
*
* @ param int $comment_id Comment ID
2008-09-21 23:39:41 -04:00
* @ return string | bool Status might be 'deleted' , 'approved' , 'unapproved' , 'spam' . False on failure .
2008-01-04 15:03:42 -05:00
*/
2006-04-18 22:32:12 -04:00
function wp_get_comment_status ( $comment_id ) {
2007-06-07 20:20:22 -04:00
$comment = get_comment ( $comment_id );
if ( ! $comment )
return false ;
$approved = $comment -> comment_approved ;
2006-12-06 22:57:23 -05:00
2007-06-07 20:20:22 -04:00
if ( $approved == NULL )
2006-04-18 22:32:12 -04:00
return 'deleted' ;
2007-06-07 20:20:22 -04:00
elseif ( $approved == '1' )
2006-04-18 22:32:12 -04:00
return 'approved' ;
2007-06-07 20:20:22 -04:00
elseif ( $approved == '0' )
2006-04-18 22:32:12 -04:00
return 'unapproved' ;
2007-06-07 20:20:22 -04:00
elseif ( $approved == 'spam' )
2006-04-18 22:32:12 -04:00
return 'spam' ;
2006-12-06 22:57:23 -05:00
else
2006-04-18 22:32:12 -04:00
return false ;
2004-12-15 21:57:05 -05:00
}
2008-10-16 00:18:45 -04:00
/**
* Call hooks for when a comment status transition occurs .
*
* Calls hooks for comment status transitions . If the new comment status is not the same
* as the previous comment status , then two hooks will be ran , the first is
* 'transition_comment_status' with new status , old status , and comment data . The
* next action called is 'comment_OLDSTATUS_to_NEWSTATUS' the NEWSTATUS is the
* $new_status parameter and the OLDSTATUS is $old_status parameter ; it has the
* comment data .
*
* The final action will run whether or not the comment statuses are the same . The
* action is named 'comment_NEWSTATUS_COMMENTTYPE' , NEWSTATUS is from the $new_status
* parameter and COMMENTTYPE is comment_type comment data .
*
* @ since 2.7 . 0
*
* @ param string $new_status New comment status .
* @ param string $old_status Previous comment status .
* @ param object $comment Comment data .
*/
function wp_transition_comment_status ( $new_status , $old_status , $comment ) {
// Translate raw statuses to human readable formats for the hooks
// This is not a complete list of comment status, it's only the ones that need to be renamed
$comment_statuses = array (
0 => 'unapproved' ,
'hold' => 'unapproved' , // wp_set_comment_status() uses "hold"
1 => 'approved' ,
'approve' => 'approved' , // wp_set_comment_status() uses "approve"
);
if ( isset ( $comment_statuses [ $new_status ]) ) $new_status = $comment_statuses [ $new_status ];
if ( isset ( $comment_statuses [ $old_status ]) ) $old_status = $comment_statuses [ $old_status ];
// Call the hooks
if ( $new_status != $old_status ) {
do_action ( 'transition_comment_status' , $new_status , $old_status , $comment );
do_action ( " comment_ ${ old_status } _to_ $new_status " , $comment );
}
2008-11-03 01:44:48 -05:00
do_action ( " comment_ ${ new_status } _ $comment->comment_type " , $comment -> comment_ID , $comment );
2008-10-16 00:18:45 -04:00
}
2008-01-04 15:03:42 -05:00
/**
2008-06-15 05:34:00 -04:00
* Get current commenter ' s name , email , and URL .
2008-01-04 15:03:42 -05:00
*
2008-09-21 23:39:41 -04:00
* Expects cookies content to already be sanitized . User of this function might
* wish to recheck the returned array for validity .
2008-01-04 15:03:42 -05:00
*
* @ see sanitize_comment_cookies () Use to sanitize cookies
*
* @ since 2.0 . 4
*
2008-09-21 23:39:41 -04:00
* @ return array Comment author , email , url respectively .
2008-01-04 15:03:42 -05:00
*/
2006-06-22 16:52:12 -04:00
function wp_get_current_commenter () {
// Cookies should already be sanitized.
$comment_author = '' ;
if ( isset ( $_COOKIE [ 'comment_author_' . COOKIEHASH ]) )
$comment_author = $_COOKIE [ 'comment_author_' . COOKIEHASH ];
$comment_author_email = '' ;
if ( isset ( $_COOKIE [ 'comment_author_email_' . COOKIEHASH ]) )
$comment_author_email = $_COOKIE [ 'comment_author_email_' . COOKIEHASH ];
$comment_author_url = '' ;
if ( isset ( $_COOKIE [ 'comment_author_url_' . COOKIEHASH ]) )
$comment_author_url = $_COOKIE [ 'comment_author_url_' . COOKIEHASH ];
return compact ( 'comment_author' , 'comment_author_email' , 'comment_author_url' );
}
2008-01-04 15:03:42 -05:00
/**
2008-06-15 05:34:00 -04:00
* Inserts a comment to the database .
2008-01-04 15:03:42 -05:00
*
2008-09-21 23:39:41 -04:00
* The available comment data key names are 'comment_author_IP' , 'comment_date' ,
* 'comment_date_gmt' , 'comment_parent' , 'comment_approved' , and 'user_id' .
2008-01-04 15:03:42 -05:00
*
* @ since 2.0 . 0
* @ uses $wpdb
*
2008-09-21 23:39:41 -04:00
* @ param array $commentdata Contains information on the comment .
* @ return int The new comment ' s ID .
2008-01-04 15:03:42 -05:00
*/
2006-04-18 22:32:12 -04:00
function wp_insert_comment ( $commentdata ) {
global $wpdb ;
2008-04-15 14:05:08 -04:00
extract ( stripslashes_deep ( $commentdata ), EXTR_SKIP );
2004-12-15 21:57:05 -05:00
2006-04-18 22:32:12 -04:00
if ( ! isset ( $comment_author_IP ) )
2008-01-26 05:18:33 -05:00
$comment_author_IP = '' ;
2006-04-18 22:32:12 -04:00
if ( ! isset ( $comment_date ) )
$comment_date = current_time ( 'mysql' );
if ( ! isset ( $comment_date_gmt ) )
2007-01-09 03:22:28 -05:00
$comment_date_gmt = get_gmt_from_date ( $comment_date );
2006-04-18 22:32:12 -04:00
if ( ! isset ( $comment_parent ) )
$comment_parent = 0 ;
if ( ! isset ( $comment_approved ) )
$comment_approved = 1 ;
if ( ! isset ( $user_id ) )
$user_id = 0 ;
2004-12-15 21:57:05 -05:00
2008-04-14 12:13:25 -04:00
$result = $wpdb -> query ( $wpdb -> prepare ( " INSERT INTO $wpdb->comments
2006-04-18 22:32:12 -04:00
( comment_post_ID , comment_author , comment_author_email , comment_author_url , comment_author_IP , comment_date , comment_date_gmt , comment_content , comment_approved , comment_agent , comment_type , comment_parent , user_id )
2008-04-14 12:13:25 -04:00
VALUES ( % d , % s , % s , % s , % s , % s , % s , % s , % s , % s , % s , % d , % d ) " ,
$comment_post_ID , $comment_author , $comment_author_email , $comment_author_url , $comment_author_IP , $comment_date , $comment_date_gmt , $comment_content , $comment_approved , $comment_agent , $comment_type , $comment_parent , $user_id ) );
2004-12-15 21:57:05 -05:00
2007-03-22 20:59:21 -04:00
$id = ( int ) $wpdb -> insert_id ;
2004-12-15 21:57:05 -05:00
2006-06-19 13:17:52 -04:00
if ( $comment_approved == 1 )
wp_update_comment_count ( $comment_post_ID );
2006-04-18 22:32:12 -04:00
return $id ;
2004-12-15 21:57:05 -05:00
}
2008-01-04 15:03:42 -05:00
/**
2008-09-21 23:39:41 -04:00
* Filters and sanitizes comment data .
2008-01-04 15:03:42 -05:00
*
2008-06-15 05:34:00 -04:00
* Sets the comment data 'filtered' field to true when finished . This can be
* checked as to whether the comment should be filtered and to keep from
* filtering the same comment more than once .
2008-01-04 15:03:42 -05:00
*
* @ since 2.0 . 0
* @ uses apply_filters () Calls 'pre_user_id' hook on comment author ' s user ID
* @ uses apply_filters () Calls 'pre_comment_user_agent' hook on comment author ' s user agent
* @ uses apply_filters () Calls 'pre_comment_author_name' hook on comment author ' s name
* @ uses apply_filters () Calls 'pre_comment_content' hook on the comment ' s content
* @ uses apply_filters () Calls 'pre_comment_user_ip' hook on comment author ' s IP
* @ uses apply_filters () Calls 'pre_comment_author_url' hook on comment author ' s URL
* @ uses apply_filters () Calls 'pre_comment_author_email' hook on comment author ' s email address
*
2008-09-22 16:21:10 -04:00
* @ param array $commentdata Contains information on the comment .
* @ return array Parsed comment information .
2008-01-04 15:03:42 -05:00
*/
2006-04-18 22:32:12 -04:00
function wp_filter_comment ( $commentdata ) {
$commentdata [ 'user_id' ] = apply_filters ( 'pre_user_id' , $commentdata [ 'user_ID' ]);
$commentdata [ 'comment_agent' ] = apply_filters ( 'pre_comment_user_agent' , $commentdata [ 'comment_agent' ]);
$commentdata [ 'comment_author' ] = apply_filters ( 'pre_comment_author_name' , $commentdata [ 'comment_author' ]);
$commentdata [ 'comment_content' ] = apply_filters ( 'pre_comment_content' , $commentdata [ 'comment_content' ]);
$commentdata [ 'comment_author_IP' ] = apply_filters ( 'pre_comment_user_ip' , $commentdata [ 'comment_author_IP' ]);
$commentdata [ 'comment_author_url' ] = apply_filters ( 'pre_comment_author_url' , $commentdata [ 'comment_author_url' ]);
$commentdata [ 'comment_author_email' ] = apply_filters ( 'pre_comment_author_email' , $commentdata [ 'comment_author_email' ]);
$commentdata [ 'filtered' ] = true ;
return $commentdata ;
2004-12-15 21:57:05 -05:00
}
2008-01-04 15:03:42 -05:00
/**
2008-09-21 23:39:41 -04:00
* Whether comment should be blocked because of comment flood .
2008-01-04 15:03:42 -05:00
*
* @ since 2.1 . 0
*
2008-09-21 23:39:41 -04:00
* @ param bool $block Whether plugin has already blocked comment .
* @ param int $time_lastcomment Timestamp for last comment .
* @ param int $time_newcomment Timestamp for new comment .
* @ return bool Whether comment should be blocked .
2008-01-04 15:03:42 -05:00
*/
2006-10-02 14:19:44 -04:00
function wp_throttle_comment_flood ( $block , $time_lastcomment , $time_newcomment ) {
if ( $block ) // a plugin has already blocked... we'll let that decision stand
return $block ;
if ( ( $time_newcomment - $time_lastcomment ) < 15 )
return true ;
return false ;
}
2008-01-04 15:03:42 -05:00
/**
2008-09-21 23:39:41 -04:00
* Adds a new comment to the database .
2008-01-04 15:03:42 -05:00
*
2008-09-21 23:39:41 -04:00
* Filters new comment to ensure that the fields are sanitized and valid before
* inserting comment into database . Calls 'comment_post' action with comment ID
* and whether comment is approved by WordPress . Also has 'preprocess_comment'
* filter for processing the comment data before the function handles it .
2008-01-04 15:03:42 -05:00
*
* @ since 1.5 . 0
* @ uses apply_filters () Calls 'preprocess_comment' hook on $commentdata parameter array before processing
* @ uses do_action () Calls 'comment_post' hook on $comment_ID returned from adding the comment and if the comment was approved .
2008-09-21 23:39:41 -04:00
* @ uses wp_filter_comment () Used to filter comment before adding comment .
2008-01-04 15:03:42 -05:00
* @ uses wp_allow_comment () checks to see if comment is approved .
2008-09-21 23:39:41 -04:00
* @ uses wp_insert_comment () Does the actual comment insertion to the database .
2008-01-04 15:03:42 -05:00
*
2008-09-22 16:21:10 -04:00
* @ param array $commentdata Contains information on the comment .
2008-01-04 15:03:42 -05:00
* @ return int The ID of the comment after adding .
*/
2006-04-18 22:32:12 -04:00
function wp_new_comment ( $commentdata ) {
$commentdata = apply_filters ( 'preprocess_comment' , $commentdata );
2005-01-24 05:13:28 -05:00
2006-04-18 22:32:12 -04:00
$commentdata [ 'comment_post_ID' ] = ( int ) $commentdata [ 'comment_post_ID' ];
$commentdata [ 'user_ID' ] = ( int ) $commentdata [ 'user_ID' ];
2005-01-24 05:13:28 -05:00
2008-08-24 02:56:22 -04:00
$commentdata [ 'comment_parent' ] = absint ( $commentdata [ 'comment_parent' ]);
$parent_status = ( 0 < $commentdata [ 'comment_parent' ] ) ? wp_get_comment_status ( $commentdata [ 'comment_parent' ]) : '' ;
$commentdata [ 'comment_parent' ] = ( 'approved' == $parent_status || 'unapproved' == $parent_status ) ? $commentdata [ 'comment_parent' ] : 0 ;
2008-01-26 05:18:33 -05:00
$commentdata [ 'comment_author_IP' ] = preg_replace ( '/[^0-9a-fA-F:., ]/' , '' , $_SERVER [ 'REMOTE_ADDR' ] );
2006-04-18 22:32:12 -04:00
$commentdata [ 'comment_agent' ] = $_SERVER [ 'HTTP_USER_AGENT' ];
2004-12-15 21:57:05 -05:00
2006-04-18 22:32:12 -04:00
$commentdata [ 'comment_date' ] = current_time ( 'mysql' );
$commentdata [ 'comment_date_gmt' ] = current_time ( 'mysql' , 1 );
2004-12-15 21:57:05 -05:00
2006-04-18 22:32:12 -04:00
$commentdata = wp_filter_comment ( $commentdata );
2004-12-15 21:57:05 -05:00
2006-04-18 22:32:12 -04:00
$commentdata [ 'comment_approved' ] = wp_allow_comment ( $commentdata );
2004-12-15 21:57:05 -05:00
2007-03-22 22:05:29 -04:00
$comment_ID = wp_insert_comment ( $commentdata );
2004-12-15 21:57:05 -05:00
2006-04-18 22:32:12 -04:00
do_action ( 'comment_post' , $comment_ID , $commentdata [ 'comment_approved' ]);
2004-12-15 21:57:05 -05:00
2006-04-18 22:32:12 -04:00
if ( 'spam' !== $commentdata [ 'comment_approved' ] ) { // If it's spam save it silently for later crunching
if ( '0' == $commentdata [ 'comment_approved' ] )
wp_notify_moderator ( $comment_ID );
2004-12-15 21:57:05 -05:00
2006-04-18 22:32:12 -04:00
$post = & get_post ( $commentdata [ 'comment_post_ID' ]); // Don't notify if it's your own comment
2004-12-15 21:57:05 -05:00
2006-08-30 17:46:31 -04:00
if ( get_option ( 'comments_notify' ) && $commentdata [ 'comment_approved' ] && $post -> post_author != $commentdata [ 'user_ID' ] )
2006-04-18 22:32:12 -04:00
wp_notify_postauthor ( $comment_ID , $commentdata [ 'comment_type' ]);
}
2004-12-15 21:57:05 -05:00
2006-04-18 22:32:12 -04:00
return $comment_ID ;
2004-12-15 21:57:05 -05:00
}
2008-01-04 15:03:42 -05:00
/**
2008-09-21 23:39:41 -04:00
* Sets the status of a comment .
2008-01-04 15:03:42 -05:00
*
2008-09-21 23:39:41 -04:00
* The 'wp_set_comment_status' action is called after the comment is handled and
* will only be called , if the comment status is either 'hold' , 'approve' , or
* 'spam' . If the comment status is not in the list , then false is returned and
* if the status is 'delete' , then the comment is deleted without calling the
* action .
2008-01-04 15:03:42 -05:00
*
* @ since 1.0 . 0
2008-10-16 00:18:45 -04:00
* @ uses wp_transition_comment_status () Passes new and old comment status along with $comment object
2008-01-04 15:03:42 -05:00
*
2008-09-21 23:39:41 -04:00
* @ param int $comment_id Comment ID .
* @ param string $comment_status New comment status , either 'hold' , 'approve' , 'spam' , or 'delete' .
2008-01-04 15:03:42 -05:00
* @ return bool False on failure or deletion and true on success .
*/
2006-04-18 22:32:12 -04:00
function wp_set_comment_status ( $comment_id , $comment_status ) {
2006-12-06 22:57:23 -05:00
global $wpdb ;
2004-12-15 21:57:05 -05:00
2006-12-06 22:57:23 -05:00
switch ( $comment_status ) {
2006-04-18 22:32:12 -04:00
case 'hold' :
2008-04-14 12:13:25 -04:00
$query = $wpdb -> prepare ( " UPDATE $wpdb->comments SET comment_approved='0' WHERE comment_ID = %d LIMIT 1 " , $comment_id );
2006-12-06 22:57:23 -05:00
break ;
2006-04-18 22:32:12 -04:00
case 'approve' :
2008-04-14 12:13:25 -04:00
$query = $wpdb -> prepare ( " UPDATE $wpdb->comments SET comment_approved='1' WHERE comment_ID = %d LIMIT 1 " , $comment_id );
2008-05-28 11:37:59 -04:00
if ( get_option ( 'comments_notify' ) ) {
$comment = get_comment ( $comment_id );
wp_notify_postauthor ( $comment_id , $comment -> comment_type );
}
2006-12-06 22:57:23 -05:00
break ;
2006-11-19 02:56:05 -05:00
case 'spam' :
2008-04-14 12:13:25 -04:00
$query = $wpdb -> prepare ( " UPDATE $wpdb->comments SET comment_approved='spam' WHERE comment_ID = %d LIMIT 1 " , $comment_id );
2006-12-06 22:57:23 -05:00
break ;
2006-04-18 22:32:12 -04:00
case 'delete' :
return wp_delete_comment ( $comment_id );
2006-12-06 22:57:23 -05:00
break ;
2006-04-18 22:32:12 -04:00
default :
return false ;
2006-12-06 22:57:23 -05:00
}
2006-11-19 02:56:05 -05:00
2006-12-08 02:35:45 -05:00
if ( ! $wpdb -> query ( $query ) )
2006-04-18 22:32:12 -04:00
return false ;
2006-12-08 02:35:45 -05:00
2007-06-07 20:20:22 -04:00
clean_comment_cache ( $comment_id );
2006-12-08 02:35:45 -05:00
$comment = get_comment ( $comment_id );
2008-10-16 00:18:45 -04:00
do_action ( 'wp_set_comment_status' , $comment_id , $comment_status );
wp_transition_comment_status ( $comment_status , $comment -> comment_approved , $comment );
2006-12-08 02:35:45 -05:00
wp_update_comment_count ( $comment -> comment_post_ID );
2007-06-07 20:20:22 -04:00
2006-12-08 02:35:45 -05:00
return true ;
2004-12-15 21:57:05 -05:00
}
2008-01-04 15:03:42 -05:00
/**
2008-09-21 23:39:41 -04:00
* Updates an existing comment in the database .
2008-01-04 15:03:42 -05:00
*
2008-09-21 23:39:41 -04:00
* Filters the comment and makes sure certain fields are valid before updating .
2008-01-04 15:03:42 -05:00
*
* @ since 2.0 . 0
* @ uses $wpdb
2008-10-16 00:18:45 -04:00
* @ uses wp_transition_comment_status () Passes new and old comment status along with $comment object
2008-01-04 15:03:42 -05:00
*
2008-09-21 23:39:41 -04:00
* @ param array $commentarr Contains information on the comment .
2008-01-04 15:03:42 -05:00
* @ return int Comment was updated if value is 1 , or was not updated if value is 0.
*/
2006-04-18 22:32:12 -04:00
function wp_update_comment ( $commentarr ) {
global $wpdb ;
2004-12-15 21:57:05 -05:00
2006-04-18 22:32:12 -04:00
// First, get all of the original fields
$comment = get_comment ( $commentarr [ 'comment_ID' ], ARRAY_A );
2004-12-15 21:57:05 -05:00
2006-04-18 22:32:12 -04:00
// Escape data pulled from DB.
2006-12-06 22:57:23 -05:00
foreach ( ( array ) $comment as $key => $value )
2006-04-18 22:32:12 -04:00
$comment [ $key ] = $wpdb -> escape ( $value );
2004-12-15 21:57:05 -05:00
2006-04-18 22:32:12 -04:00
// Merge old and new fields with new fields overwriting old ones.
$commentarr = array_merge ( $comment , $commentarr );
2004-12-15 22:08:07 -05:00
2006-04-18 22:32:12 -04:00
$commentarr = wp_filter_comment ( $commentarr );
2004-12-15 21:57:05 -05:00
2006-04-18 22:32:12 -04:00
// Now extract the merged array.
2008-04-15 14:05:08 -04:00
extract ( stripslashes_deep ( $commentarr ), EXTR_SKIP );
2004-12-15 21:57:05 -05:00
2006-04-18 22:32:12 -04:00
$comment_content = apply_filters ( 'comment_save_pre' , $comment_content );
2004-12-15 21:57:05 -05:00
2007-01-09 03:22:28 -05:00
$comment_date_gmt = get_gmt_from_date ( $comment_date );
2008-08-12 12:23:47 -04:00
if ( ! isset ( $comment_approved ) )
2008-08-04 18:29:37 -04:00
$comment_approved = 1 ;
else if ( 'hold' == $comment_approved )
$comment_approved = 0 ;
else if ( 'approve' == $comment_approved )
$comment_approved = 1 ;
2008-04-14 12:13:25 -04:00
$wpdb -> query ( $wpdb -> prepare ( " UPDATE $wpdb->comments SET
comment_content = % s ,
comment_author = % s ,
comment_author_email = % s ,
comment_approved = % s ,
comment_author_url = % s ,
comment_date = % s ,
comment_date_gmt = % s
WHERE comment_ID = % d " ,
$comment_content ,
$comment_author ,
$comment_author_email ,
$comment_approved ,
$comment_author_url ,
$comment_date ,
2008-04-14 12:45:12 -04:00
$comment_date_gmt ,
2008-04-14 12:13:25 -04:00
$comment_ID ) );
2004-12-15 21:57:05 -05:00
2006-04-18 22:32:12 -04:00
$rval = $wpdb -> rows_affected ;
2007-06-07 20:20:22 -04:00
clean_comment_cache ( $comment_ID );
2006-06-19 13:17:52 -04:00
wp_update_comment_count ( $comment_post_ID );
2006-04-18 22:32:12 -04:00
do_action ( 'edit_comment' , $comment_ID );
2008-11-03 01:44:48 -05:00
$comment = get_comment ( $comment_ID );
2008-10-16 00:18:45 -04:00
wp_transition_comment_status ( $comment_approved , $comment -> comment_approved , $comment );
2006-04-18 22:32:12 -04:00
return $rval ;
2004-12-15 21:57:05 -05:00
}
2008-01-04 15:03:42 -05:00
/**
2008-06-15 05:34:00 -04:00
* Whether to defer comment counting .
2008-01-04 15:03:42 -05:00
*
* When setting $defer to true , all post comment counts will not be updated
* until $defer is set to false . When $defer is set to false , then all
* previously deferred updated post comment counts will then be automatically
* updated without having to call wp_update_comment_count () after .
*
2008-09-21 23:39:41 -04:00
* @ since 2.5 . 0
2008-01-04 15:03:42 -05:00
* @ staticvar bool $_defer
*
* @ param bool $defer
* @ return unknown
*/
function wp_defer_comment_counting ( $defer = null ) {
2008-01-01 12:03:52 -05:00
static $_defer = false ;
2008-02-05 01:47:27 -05:00
2008-01-01 12:03:52 -05:00
if ( is_bool ( $defer ) ) {
$_defer = $defer ;
// flush any deferred counts
if ( ! $defer )
2008-01-04 15:03:42 -05:00
wp_update_comment_count ( null , true );
2008-01-01 12:03:52 -05:00
}
2008-02-05 01:47:27 -05:00
2008-01-01 12:03:52 -05:00
return $_defer ;
}
2008-01-04 15:03:42 -05:00
/**
2008-06-15 05:34:00 -04:00
* Updates the comment count for post ( s ) .
2008-01-04 15:03:42 -05:00
*
2008-06-15 05:34:00 -04:00
* When $do_deferred is false ( is by default ) and the comments have been set to
* be deferred , the post_id will be added to a queue , which will be updated at a
* later date and only updated once per post ID .
2008-01-04 15:03:42 -05:00
*
2008-06-15 05:34:00 -04:00
* If the comments have not be set up to be deferred , then the post will be
* updated . When $do_deferred is set to true , then all previous deferred post
* IDs will be updated along with the current $post_id .
2008-01-04 15:03:42 -05:00
*
* @ since 2.1 . 0
* @ see wp_update_comment_count_now () For what could cause a false return value
*
* @ param int $post_id Post ID
* @ param bool $do_deferred Whether to process previously deferred post comment counts
* @ return bool True on success , false on failure
*/
2008-01-01 12:03:52 -05:00
function wp_update_comment_count ( $post_id , $do_deferred = false ) {
static $_deferred = array ();
2008-02-05 01:47:27 -05:00
2008-01-01 12:03:52 -05:00
if ( $do_deferred ) {
$_deferred = array_unique ( $_deferred );
foreach ( $_deferred as $i => $_post_id ) {
wp_update_comment_count_now ( $_post_id );
2008-01-04 15:03:42 -05:00
unset ( $_deferred [ $i ] ); /** @todo Move this outside of the foreach and reset $_deferred to an array instead */
2008-01-01 12:03:52 -05:00
}
}
2008-02-05 01:47:27 -05:00
2008-01-01 12:03:52 -05:00
if ( wp_defer_comment_counting () ) {
$_deferred [] = $post_id ;
return true ;
}
elseif ( $post_id ) {
return wp_update_comment_count_now ( $post_id );
}
2008-02-05 01:47:27 -05:00
2008-01-01 12:03:52 -05:00
}
2006-12-06 22:57:23 -05:00
2008-01-04 15:03:42 -05:00
/**
2008-06-15 05:34:00 -04:00
* Updates the comment count for the post .
2008-01-04 15:03:42 -05:00
*
2008-09-21 23:39:41 -04:00
* @ since 2.5 . 0
2008-01-04 15:03:42 -05:00
* @ uses $wpdb
* @ uses do_action () Calls 'wp_update_comment_count' hook on $post_id , $new , and $old
* @ uses do_action () Calls 'edit_posts' hook on $post_id and $post
*
* @ param int $post_id Post ID
2008-02-05 01:47:27 -05:00
* @ return bool False on '0' $post_id or if post with ID does not exist . True on success .
2008-01-04 15:03:42 -05:00
*/
2008-01-01 12:03:52 -05:00
function wp_update_comment_count_now ( $post_id ) {
2007-11-29 00:03:25 -05:00
global $wpdb ;
2006-06-19 13:17:52 -04:00
$post_id = ( int ) $post_id ;
if ( ! $post_id )
return false ;
2007-08-13 23:08:44 -04:00
if ( ! $post = get_post ( $post_id ) )
return false ;
$old = ( int ) $post -> comment_count ;
2008-04-14 12:13:25 -04:00
$new = ( int ) $wpdb -> get_var ( $wpdb -> prepare ( " SELECT COUNT(*) FROM $wpdb->comments WHERE comment_post_ID = %d AND comment_approved = '1' " , $post_id ) );
$wpdb -> query ( $wpdb -> prepare ( " UPDATE $wpdb->posts SET comment_count = %d WHERE ID = %d " , $new , $post_id ) );
2006-12-08 02:35:45 -05:00
if ( 'page' == $post -> post_type )
clean_page_cache ( $post_id );
else
clean_post_cache ( $post_id );
2007-08-13 23:08:44 -04:00
do_action ( 'wp_update_comment_count' , $post_id , $new , $old );
do_action ( 'edit_post' , $post_id , $post );
2006-12-08 02:35:45 -05:00
2006-06-19 13:17:52 -04:00
return true ;
}
2006-06-22 15:44:36 -04:00
//
// Ping and trackback functions.
//
2004-12-15 21:57:05 -05:00
2008-01-04 15:03:42 -05:00
/**
2008-06-15 05:34:00 -04:00
* Finds a pingback server URI based on the given URL .
2008-01-04 15:03:42 -05:00
*
2008-09-21 23:39:41 -04:00
* Checks the HTML for the rel = " pingback " link and x - pingback headers . It does
* a check for the x - pingback headers first and returns that , if available . The
* check for the rel = " pingback " has more overhead than just the header .
2008-01-04 15:03:42 -05:00
*
* @ since 1.5 . 0
*
2008-09-21 23:39:41 -04:00
* @ param string $url URL to ping .
2008-09-27 17:40:09 -04:00
* @ param int $deprecated Not Used .
2008-01-04 15:03:42 -05:00
* @ return bool | string False on failure , string containing URI on success .
*/
2008-09-27 17:40:09 -04:00
function discover_pingback_server_uri ( $url , $deprecated = 2048 ) {
2004-12-15 21:57:05 -05:00
$pingback_str_dquote = 'rel="pingback"' ;
$pingback_str_squote = 'rel=\'pingback\'' ;
2008-09-27 17:40:09 -04:00
/** @todo Should use Filter Extension or custom preg_match instead. */
$parsed_url = parse_url ( $url );
2004-12-15 21:57:05 -05:00
2008-09-27 17:40:09 -04:00
if ( ! isset ( $parsed_url [ 'host' ] ) ) // Not an URL. This should never happen.
2004-12-15 21:57:05 -05:00
return false ;
2008-09-27 17:40:09 -04:00
$response = wp_remote_get ( $url , array ( 'timeout' => 2 , 'httpversion' => '1.1' ) );
2004-12-15 21:57:05 -05:00
2008-09-27 17:40:09 -04:00
if ( is_wp_error ( $response ) )
2004-12-15 21:57:05 -05:00
return false ;
2008-09-27 17:40:09 -04:00
if ( isset ( $response [ 'headers' ][ 'x-pingback' ] ) )
return $response [ 'headers' ][ 'x-pingback' ];
2004-12-15 21:57:05 -05:00
2008-09-27 17:40:09 -04:00
// Not an (x)html, sgml, or xml page, no use going further.
if ( isset ( $response [ 'headers' ][ 'content-type' ] ) && preg_match ( '#(image|audio|video|model)/#is' , $response [ 'headers' ][ 'content-type' ]) )
2004-12-15 21:57:05 -05:00
return false ;
2008-09-27 17:40:09 -04:00
$contents = $response [ 'body' ];
$pingback_link_offset_dquote = strpos ( $contents , $pingback_str_dquote );
$pingback_link_offset_squote = strpos ( $contents , $pingback_str_squote );
if ( $pingback_link_offset_dquote || $pingback_link_offset_squote ) {
$quote = ( $pingback_link_offset_dquote ) ? '"' : '\'' ;
$pingback_link_offset = ( $quote == '"' ) ? $pingback_link_offset_dquote : $pingback_link_offset_squote ;
$pingback_href_pos = @ strpos ( $contents , 'href=' , $pingback_link_offset );
$pingback_href_start = $pingback_href_pos + 6 ;
$pingback_href_end = @ strpos ( $contents , $quote , $pingback_href_start );
$pingback_server_url_len = $pingback_href_end - $pingback_href_start ;
$pingback_server_url = substr ( $contents , $pingback_href_start , $pingback_server_url_len );
// We may find rel="pingback" but an incomplete pingback URL
if ( $pingback_server_url_len > 0 ) { // We got it!
return $pingback_server_url ;
2004-12-15 21:57:05 -05:00
}
}
return false ;
}
2008-01-04 15:03:42 -05:00
/**
2008-09-21 23:39:41 -04:00
* Perform all pingbacks , enclosures , trackbacks , and send to pingback services .
2008-01-04 15:03:42 -05:00
*
* @ since 2.1 . 0
* @ uses $wpdb
*/
2006-06-22 15:44:36 -04:00
function do_all_pings () {
global $wpdb ;
// Do pingbacks
while ( $ping = $wpdb -> get_row ( " SELECT * FROM { $wpdb -> posts } , { $wpdb -> postmeta } WHERE { $wpdb -> posts } .ID = { $wpdb -> postmeta } .post_id AND { $wpdb -> postmeta } .meta_key = '_pingme' LIMIT 1 " )) {
$wpdb -> query ( " DELETE FROM { $wpdb -> postmeta } WHERE post_id = { $ping -> ID } AND meta_key = '_pingme'; " );
pingback ( $ping -> post_content , $ping -> ID );
2006-02-12 02:53:23 -05:00
}
2006-11-19 02:56:05 -05:00
2006-06-22 15:44:36 -04:00
// Do Enclosures
while ( $enclosure = $wpdb -> get_row ( " SELECT * FROM { $wpdb -> posts } , { $wpdb -> postmeta } WHERE { $wpdb -> posts } .ID = { $wpdb -> postmeta } .post_id AND { $wpdb -> postmeta } .meta_key = '_encloseme' LIMIT 1 " )) {
2008-04-14 12:13:25 -04:00
$wpdb -> query ( $wpdb -> prepare ( " DELETE FROM { $wpdb -> postmeta } WHERE post_id = %d AND meta_key = '_encloseme'; " , $enclosure -> ID ) );
2006-06-22 15:44:36 -04:00
do_enclose ( $enclosure -> post_content , $enclosure -> ID );
}
// Do Trackbacks
2008-01-22 00:50:22 -05:00
$trackbacks = $wpdb -> get_col ( " SELECT ID FROM $wpdb->posts WHERE to_ping <> '' AND post_status = 'publish' " );
if ( is_array ( $trackbacks ) )
2006-12-06 22:57:23 -05:00
foreach ( $trackbacks as $trackback )
2008-01-22 00:50:22 -05:00
do_trackbacks ( $trackback );
2006-06-22 15:44:36 -04:00
//Do Update Services/Generic Pings
generic_ping ();
}
2008-01-04 15:03:42 -05:00
/**
2008-09-21 23:39:41 -04:00
* Perform trackbacks .
2008-01-04 15:03:42 -05:00
*
* @ since 1.5 . 0
* @ uses $wpdb
*
2008-09-21 23:39:41 -04:00
* @ param int $post_id Post ID to do trackbacks on .
2008-01-04 15:03:42 -05:00
*/
2006-06-22 15:44:36 -04:00
function do_trackbacks ( $post_id ) {
global $wpdb ;
2008-04-14 12:13:25 -04:00
$post = $wpdb -> get_row ( $wpdb -> prepare ( " SELECT * FROM $wpdb->posts WHERE ID = %d " , $post_id ) );
2006-06-22 15:44:36 -04:00
$to_ping = get_to_ping ( $post_id );
$pinged = get_pung ( $post_id );
if ( empty ( $to_ping ) ) {
2008-04-14 12:13:25 -04:00
$wpdb -> query ( $wpdb -> prepare ( " UPDATE $wpdb->posts SET to_ping = '' WHERE ID = %d " , $post_id ) );
2006-06-22 15:44:36 -04:00
return ;
}
2006-12-06 22:57:23 -05:00
if ( empty ( $post -> post_excerpt ) )
2006-06-22 15:44:36 -04:00
$excerpt = apply_filters ( 'the_content' , $post -> post_content );
else
$excerpt = apply_filters ( 'the_excerpt' , $post -> post_excerpt );
$excerpt = str_replace ( ']]>' , ']]>' , $excerpt );
2008-03-03 16:05:23 -05:00
$excerpt = wp_html_excerpt ( $excerpt , 252 ) . '...' ;
2006-06-22 15:44:36 -04:00
$post_title = apply_filters ( 'the_title' , $post -> post_title );
$post_title = strip_tags ( $post_title );
2006-12-06 22:57:23 -05:00
if ( $to_ping ) {
foreach ( ( array ) $to_ping as $tb_ping ) {
$tb_ping = trim ( $tb_ping );
if ( ! in_array ( $tb_ping , $pinged ) ) {
trackback ( $tb_ping , $post_title , $excerpt , $post_id );
$pinged [] = $tb_ping ;
} else {
2008-04-14 12:13:25 -04:00
$wpdb -> query ( $wpdb -> prepare ( " UPDATE $wpdb->posts SET to_ping = TRIM(REPLACE(to_ping, ' $tb_ping ', '')) WHERE ID = %d " , $post_id ) );
2006-12-06 22:57:23 -05:00
}
2006-06-22 15:44:36 -04:00
}
2006-12-06 22:57:23 -05:00
}
2006-06-22 15:44:36 -04:00
}
2008-01-04 15:03:42 -05:00
/**
2008-09-21 23:39:41 -04:00
* Sends pings to all of the ping site services .
2008-01-04 15:03:42 -05:00
*
* @ since 1.2 . 0
*
* @ param int $post_id Post ID . Not actually used .
* @ return int Same as Post ID from parameter
*/
2006-06-22 15:44:36 -04:00
function generic_ping ( $post_id = 0 ) {
2006-08-30 17:46:31 -04:00
$services = get_option ( 'ping_sites' );
2008-02-14 16:50:43 -05:00
$services = explode ( " \n " , $services );
foreach ( ( array ) $services as $service ) {
$service = trim ( $service );
if ( '' != $service )
2006-06-22 15:44:36 -04:00
weblog_ping ( $service );
}
return $post_id ;
}
2008-01-04 15:03:42 -05:00
/**
2008-06-15 05:34:00 -04:00
* Pings back the links found in a post .
2008-01-04 15:03:42 -05:00
*
* @ since 0.71
* @ uses $wp_version
* @ uses IXR_Client
*
2008-09-21 23:39:41 -04:00
* @ param string $content Post content to check for links .
* @ param int $post_ID Post ID .
2008-01-04 15:03:42 -05:00
*/
2006-06-22 15:44:36 -04:00
function pingback ( $content , $post_ID ) {
2007-12-06 14:49:33 -05:00
global $wp_version ;
2006-12-06 22:57:23 -05:00
include_once ( ABSPATH . WPINC . '/class-IXR.php' );
2006-06-22 15:44:36 -04:00
// original code by Mort (http://mort.mine.nu:8080)
$post_links = array ();
$pung = get_pung ( $post_ID );
// Variables
$ltrs = '\w' ;
$gunk = '/#~:.?+=&%@!\-' ;
$punc = '.:?\-' ;
$any = $ltrs . $gunk . $punc ;
// Step 1
// Parsing the post, external links (if any) are stored in the $post_links array
// This regexp comes straight from phpfreaks.com
// http://www.phpfreaks.com/quickcode/Extract_All_URLs_on_a_Page/15.php
preg_match_all ( " { \ b http : [ $any ] +? (?= [ $punc ] * [^ $any ] | $ )}x " , $content , $post_links_temp );
// Step 2.
// Walking thru the links array
// first we get rid of links pointing to sites, not to specific files
// Example:
// http://dummy-weblog.org
// http://dummy-weblog.org/
// http://dummy-weblog.org/post.php
// We don't wanna ping first and second types, even if they have a valid <link/>
2008-08-06 16:31:54 -04:00
foreach ( ( array ) $post_links_temp [ 0 ] as $link_test ) :
2006-06-22 15:44:36 -04:00
if ( ! in_array ( $link_test , $pung ) && ( url_to_postid ( $link_test ) != $post_ID ) // If we haven't pung it already and it isn't a link to itself
&& ! is_local_attachment ( $link_test ) ) : // Also, let's never ping local attachments.
$test = parse_url ( $link_test );
2006-12-06 22:57:23 -05:00
if ( isset ( $test [ 'query' ]) )
2006-06-22 15:44:36 -04:00
$post_links [] = $link_test ;
2006-12-06 22:57:23 -05:00
elseif ( ( $test [ 'path' ] != '/' ) && ( $test [ 'path' ] != '' ) )
2006-06-22 15:44:36 -04:00
$post_links [] = $link_test ;
endif ;
endforeach ;
2006-12-06 22:57:23 -05:00
do_action_ref_array ( 'pre_ping' , array ( & $post_links , & $pung ));
2006-06-22 15:44:36 -04:00
2006-12-06 22:57:23 -05:00
foreach ( ( array ) $post_links as $pagelinkedto ) {
2006-06-22 15:44:36 -04:00
$pingback_server_url = discover_pingback_server_uri ( $pagelinkedto , 2048 );
2006-12-06 22:57:23 -05:00
if ( $pingback_server_url ) {
2006-11-19 02:56:05 -05:00
@ set_time_limit ( 60 );
2006-06-22 15:44:36 -04:00
// Now, the RPC call
$pagelinkedfrom = get_permalink ( $post_ID );
// using a timeout of 3 seconds should be enough to cover slow servers
$client = new IXR_Client ( $pingback_server_url );
$client -> timeout = 3 ;
$client -> useragent .= ' -- WordPress/' . $wp_version ;
// when set to true, this outputs debug messages by itself
$client -> debug = false ;
2007-06-27 19:28:36 -04:00
if ( $client -> query ( 'pingback.ping' , $pagelinkedfrom , $pagelinkedto ) || ( isset ( $client -> error -> code ) && 48 == $client -> error -> code ) ) // Already registered
2006-06-22 15:44:36 -04:00
add_ping ( $post_ID , $pagelinkedto );
}
}
}
2008-01-04 15:03:42 -05:00
/**
2008-09-21 23:39:41 -04:00
* Check whether blog is public before returning sites .
2008-01-04 15:03:42 -05:00
*
* @ since 2.1 . 0
*
2008-09-21 23:39:41 -04:00
* @ param mixed $sites Will return if blog is public , will not return if not public .
* @ return mixed Empty string if blog is not public , returns $sites , if site is public .
2008-01-04 15:03:42 -05:00
*/
2006-12-06 22:57:23 -05:00
function privacy_ping_filter ( $sites ) {
2006-06-22 15:44:36 -04:00
if ( '0' != get_option ( 'blog_public' ) )
return $sites ;
else
return '' ;
}
2008-01-04 15:03:42 -05:00
/**
2008-06-15 05:34:00 -04:00
* Send a Trackback .
2008-01-04 15:03:42 -05:00
*
2008-06-15 05:34:00 -04:00
* Updates database when sending trackback to prevent duplicates .
2008-01-04 15:03:42 -05:00
*
* @ since 0.71
* @ uses $wpdb
*
2008-06-15 05:34:00 -04:00
* @ param string $trackback_url URL to send trackbacks .
2008-09-21 23:39:41 -04:00
* @ param string $title Title of post .
* @ param string $excerpt Excerpt of post .
* @ param int $ID Post ID .
* @ return mixed Database query from update .
2008-01-04 15:03:42 -05:00
*/
2006-06-22 15:44:36 -04:00
function trackback ( $trackback_url , $title , $excerpt , $ID ) {
2008-09-27 17:40:09 -04:00
global $wpdb ;
2006-06-22 15:44:36 -04:00
if ( empty ( $trackback_url ) )
return ;
2008-09-27 17:40:09 -04:00
$options = array ();
$options [ 'timeout' ] = 4 ;
$options [ 'body' ] = array (
2008-10-22 18:48:14 -04:00
'title' => $title ,
'url' => get_permalink ( $ID ),
'blog_name' => get_option ( 'blogname' ),
'excerpt' => $excerpt
2008-09-27 17:40:09 -04:00
);
2008-10-01 20:32:21 -04:00
$response = wp_remote_post ( $trackback_url , $options );
if ( is_wp_error ( $response ) )
return ;
2008-09-27 17:40:09 -04:00
$tb_url = addslashes ( $trackback_url );
2008-04-14 12:13:25 -04:00
$wpdb -> query ( $wpdb -> prepare ( " UPDATE $wpdb->posts SET pinged = CONCAT(pinged, ' \n ', ' $tb_url ') WHERE ID = %d " , $ID ) );
return $wpdb -> query ( $wpdb -> prepare ( " UPDATE $wpdb->posts SET to_ping = TRIM(REPLACE(to_ping, ' $tb_url ', '')) WHERE ID = %d " , $ID ) );
2006-06-22 15:44:36 -04:00
}
2008-01-04 15:03:42 -05:00
/**
2008-06-15 05:34:00 -04:00
* Send a pingback .
2008-01-04 15:03:42 -05:00
*
* @ since 1.2 . 0
* @ uses $wp_version
* @ uses IXR_Client
*
2008-06-15 05:34:00 -04:00
* @ param string $server Host of blog to connect to .
* @ param string $path Path to send the ping .
2008-01-04 15:03:42 -05:00
*/
2006-06-22 15:44:36 -04:00
function weblog_ping ( $server = '' , $path = '' ) {
global $wp_version ;
2006-12-06 22:57:23 -05:00
include_once ( ABSPATH . WPINC . '/class-IXR.php' );
2006-06-22 15:44:36 -04:00
// using a timeout of 3 seconds should be enough to cover slow servers
$client = new IXR_Client ( $server , (( ! strlen ( trim ( $path )) || ( '/' == $path )) ? false : $path ));
$client -> timeout = 3 ;
$client -> useragent .= ' -- WordPress/' . $wp_version ;
// when set to true, this outputs debug messages by itself
$client -> debug = false ;
$home = trailingslashit ( get_option ( 'home' ) );
2006-08-30 17:46:31 -04:00
if ( ! $client -> query ( 'weblogUpdates.extendedPing' , get_option ( 'blogname' ), $home , get_bloginfo ( 'rss2_url' ) ) ) // then try a normal ping
$client -> query ( 'weblogUpdates.ping' , get_option ( 'blogname' ), $home );
2005-11-18 04:25:47 -05:00
}
2004-12-15 21:57:05 -05:00
2007-06-07 20:20:22 -04:00
//
// Cache
//
2008-01-04 15:03:42 -05:00
/**
2008-06-15 05:34:00 -04:00
* Removes comment ID from the comment cache .
2008-01-04 15:03:42 -05:00
*
* @ since 2.3 . 0
* @ package WordPress
* @ subpackage Cache
*
* @ param int $id Comment ID to remove from cache
*/
2007-06-07 20:20:22 -04:00
function clean_comment_cache ( $id ) {
wp_cache_delete ( $id , 'comment' );
}
2008-01-04 15:03:42 -05:00
/**
2008-06-15 05:34:00 -04:00
* Updates the comment cache of given comments .
2008-01-04 15:03:42 -05:00
*
2008-09-21 23:39:41 -04:00
* Will add the comments in $comments to the cache . If comment ID already exists
* in the comment cache then it will not be updated . The comment is added to the
* cache using the comment group with the key using the ID of the comments .
2008-01-04 15:03:42 -05:00
*
* @ since 2.3 . 0
2008-09-21 23:39:41 -04:00
* @ package WordPress
* @ subpackage Cache
2008-01-04 15:03:42 -05:00
*
* @ param array $comments Array of comment row objects
*/
2007-06-07 20:20:22 -04:00
function update_comment_cache ( $comments ) {
2008-01-04 15:03:42 -05:00
foreach ( ( array ) $comments as $comment )
2007-06-07 20:20:22 -04:00
wp_cache_add ( $comment -> comment_ID , $comment , 'comment' );
}
2008-09-15 12:26:37 -04:00
//
// Internal
//
/**
2008-09-27 23:31:26 -04:00
* Close comments on old posts on the fly , without any extra DB queries . Hooked to the_posts .
2008-09-15 12:26:37 -04:00
*
2008-09-21 23:39:41 -04:00
* @ access private
* @ since 2.7 . 0
*
* @ param object $posts Post data object .
* @ return object
2008-09-15 12:26:37 -04:00
*/
function _close_comments_for_old_posts ( $posts ) {
2008-10-27 21:20:38 -04:00
if ( empty ( $posts ) || ! is_single () || ! get_option ( 'close_comments_for_old_posts' ) )
2008-09-15 12:26:37 -04:00
return $posts ;
$days_old = ( int ) get_option ( 'close_comments_days_old' );
if ( ! $days_old )
return $posts ;
if ( time () - strtotime ( $posts [ 0 ] -> post_date_gmt ) > ( $days_old * 24 * 60 * 60 ) ) {
$posts [ 0 ] -> comment_status = 'closed' ;
$posts [ 0 ] -> ping_status = 'closed' ;
}
return $posts ;
}
2008-09-27 23:31:26 -04:00
/**
* Close comments on an old post . Hooked to comments_open .
*
* @ access private
* @ since 2.7 . 0
*
* @ param bool $open Comments open or closed
* @ param int $post_id Post ID
* @ return bool $open
*/
function _close_comments_for_old_post ( $open , $post_id ) {
if ( ! $open )
return $open ;
if ( ! get_option ( 'close_comments_for_old_posts' ) )
return $open ;
$days_old = ( int ) get_option ( 'close_comments_days_old' );
if ( ! $days_old )
return $open ;
$post = get_post ( $post_id );
if ( time () - strtotime ( $post -> post_date_gmt ) > ( $days_old * 24 * 60 * 60 ) )
return false ;
return $open ;
}
2007-08-13 23:08:44 -04:00
?>