| [ Index ] |
PHP Cross Reference of WordPress Trunk (Updated Daily) |
[Summary view] [Print] [Text view]
1 <?php 2 /** 3 * Core Comment API 4 * 5 * @package WordPress 6 * @subpackage Comment 7 */ 8 9 /** 10 * Checks whether a comment passes internal checks to be allowed to add. 11 * 12 * If manual comment moderation is set in the administration, then all checks, 13 * regardless of their type and substance, will fail and the function will 14 * return false. 15 * 16 * If the number of links exceeds the amount in the administration, then the 17 * check fails. If any of the parameter contents contain any disallowed words, 18 * then the check fails. 19 * 20 * If the comment author was approved before, then the comment is automatically 21 * approved. 22 * 23 * If all checks pass, the function will return true. 24 * 25 * @since 1.2.0 26 * 27 * @global wpdb $wpdb WordPress database abstraction object. 28 * 29 * @param string $author Comment author name. 30 * @param string $email Comment author email. 31 * @param string $url Comment author URL. 32 * @param string $comment Content of the comment. 33 * @param string $user_ip Comment author IP address. 34 * @param string $user_agent Comment author User-Agent. 35 * @param string $comment_type Comment type, either user-submitted comment, 36 * trackback, or pingback. 37 * @return bool If all checks pass, true, otherwise false. 38 */ 39 function check_comment( $author, $email, $url, $comment, $user_ip, $user_agent, $comment_type ) { 40 global $wpdb; 41 42 // If manual moderation is enabled, skip all checks and return false. 43 if ( '1' === get_option( 'comment_moderation' ) ) { 44 return false; 45 } 46 47 /** This filter is documented in wp-includes/comment-template.php */ 48 $comment = apply_filters( 'comment_text', $comment, null, array() ); 49 50 // Check for the number of external links if a max allowed number is set. 51 $max_links = get_option( 'comment_max_links' ); 52 if ( $max_links ) { 53 $num_links = preg_match_all( '/<a [^>]*href/i', $comment, $out ); 54 55 /** 56 * Filters the number of links found in a comment. 57 * 58 * @since 3.0.0 59 * @since 4.7.0 Added the `$comment` parameter. 60 * 61 * @param int $num_links The number of links found. 62 * @param string $url Comment author's URL. Included in allowed links total. 63 * @param string $comment Content of the comment. 64 */ 65 $num_links = apply_filters( 'comment_max_links_url', $num_links, $url, $comment ); 66 67 /* 68 * If the number of links in the comment exceeds the allowed amount, 69 * fail the check by returning false. 70 */ 71 if ( $num_links >= $max_links ) { 72 return false; 73 } 74 } 75 76 $mod_keys = trim( get_option( 'moderation_keys' ) ); 77 78 // If moderation 'keys' (keywords) are set, process them. 79 if ( ! empty( $mod_keys ) ) { 80 $words = explode( "\n", $mod_keys ); 81 82 foreach ( (array) $words as $word ) { 83 $word = trim( $word ); 84 85 // Skip empty lines. 86 if ( empty( $word ) ) { 87 continue; 88 } 89 90 /* 91 * Do some escaping magic so that '#' (number of) characters in the spam 92 * words don't break things: 93 */ 94 $word = preg_quote( $word, '#' ); 95 96 /* 97 * Check the comment fields for moderation keywords. If any are found, 98 * fail the check for the given field by returning false. 99 */ 100 $pattern = "#$word#iu"; 101 if ( preg_match( $pattern, $author ) ) { 102 return false; 103 } 104 if ( preg_match( $pattern, $email ) ) { 105 return false; 106 } 107 if ( preg_match( $pattern, $url ) ) { 108 return false; 109 } 110 if ( preg_match( $pattern, $comment ) ) { 111 return false; 112 } 113 if ( preg_match( $pattern, $user_ip ) ) { 114 return false; 115 } 116 if ( preg_match( $pattern, $user_agent ) ) { 117 return false; 118 } 119 } 120 } 121 122 /* 123 * Check if the option to approve comments by previously-approved authors is enabled. 124 * 125 * If it is enabled, check whether the comment author has a previously-approved comment, 126 * as well as whether there are any moderation keywords (if set) present in the author 127 * email address. If both checks pass, return true. Otherwise, return false. 128 */ 129 if ( '1' === get_option( 'comment_previously_approved' ) ) { 130 if ( 'trackback' !== $comment_type && 'pingback' !== $comment_type && '' !== $author && '' !== $email ) { 131 $comment_user = get_user_by( 'email', wp_unslash( $email ) ); 132 if ( ! empty( $comment_user->ID ) ) { 133 $ok_to_comment = $wpdb->get_var( 134 $wpdb->prepare( 135 "SELECT comment_approved 136 FROM $wpdb->comments 137 WHERE user_id = %d 138 AND comment_approved = '1' 139 LIMIT 1", 140 $comment_user->ID 141 ) 142 ); 143 } else { 144 // expected_slashed ($author, $email) 145 $ok_to_comment = $wpdb->get_var( 146 $wpdb->prepare( 147 "SELECT comment_approved 148 FROM $wpdb->comments 149 WHERE comment_author = %s 150 AND comment_author_email = %s 151 AND comment_approved = '1' 152 LIMIT 1", 153 $author, 154 $email 155 ) 156 ); 157 } 158 159 if ( '1' === $ok_to_comment && ( empty( $mod_keys ) || ! str_contains( $email, $mod_keys ) ) ) { 160 return true; 161 } else { 162 return false; 163 } 164 } else { 165 return false; 166 } 167 } 168 return true; 169 } 170 171 /** 172 * Retrieves the approved comments for a post. 173 * 174 * @since 2.0.0 175 * @since 4.1.0 Refactored to leverage WP_Comment_Query over a direct query. 176 * 177 * @param int $post_id The ID of the post. 178 * @param array $args { 179 * Optional. See WP_Comment_Query::__construct() for information on accepted arguments. 180 * 181 * @type int $status Comment status to limit results by. Defaults to approved comments. 182 * @type int $post_id Limit results to those affiliated with a given post ID. 183 * @type string $order How to order retrieved comments. Default 'ASC'. 184 * } 185 * @return WP_Comment[]|int[]|int The approved comments, or number of comments if `$count` 186 * argument is true. 187 */ 188 function get_approved_comments( $post_id, $args = array() ) { 189 if ( ! $post_id ) { 190 return array(); 191 } 192 193 $defaults = array( 194 'status' => 1, 195 'post_id' => $post_id, 196 'order' => 'ASC', 197 ); 198 $parsed_args = wp_parse_args( $args, $defaults ); 199 200 $query = new WP_Comment_Query(); 201 return $query->query( $parsed_args ); 202 } 203 204 /** 205 * Retrieves comment data given a comment ID or comment object. 206 * 207 * If an object is passed then the comment data will be cached and then returned 208 * after being passed through a filter. If the comment is empty, then the global 209 * comment variable will be used, if it is set. 210 * 211 * @since 2.0.0 212 * 213 * @global WP_Comment $comment Global comment object. 214 * 215 * @param WP_Comment|string|int $comment Comment to retrieve. 216 * @param string $output Optional. The required return type. One of OBJECT, ARRAY_A, or ARRAY_N, which 217 * correspond to a WP_Comment object, an associative array, or a numeric array, 218 * respectively. Default OBJECT. 219 * @return WP_Comment|array|null Depends on $output value. 220 */ 221 function get_comment( $comment = null, $output = OBJECT ) { 222 if ( empty( $comment ) && isset( $GLOBALS['comment'] ) ) { 223 $comment = $GLOBALS['comment']; 224 } 225 226 if ( $comment instanceof WP_Comment ) { 227 $_comment = $comment; 228 } elseif ( is_object( $comment ) ) { 229 $_comment = new WP_Comment( $comment ); 230 } else { 231 $_comment = WP_Comment::get_instance( $comment ); 232 } 233 234 if ( ! $_comment ) { 235 return null; 236 } 237 238 /** 239 * Fires after a comment is retrieved. 240 * 241 * @since 2.3.0 242 * 243 * @param WP_Comment $_comment Comment data. 244 */ 245 $_comment = apply_filters( 'get_comment', $_comment ); 246 247 if ( OBJECT === $output ) { 248 return $_comment; 249 } elseif ( ARRAY_A === $output ) { 250 return $_comment->to_array(); 251 } elseif ( ARRAY_N === $output ) { 252 return array_values( $_comment->to_array() ); 253 } 254 return $_comment; 255 } 256 257 /** 258 * Retrieves a list of comments. 259 * 260 * The comment list can be for the blog as a whole or for an individual post. 261 * 262 * @since 2.7.0 263 * 264 * @param string|array $args Optional. Array or string of arguments. See WP_Comment_Query::__construct() 265 * for information on accepted arguments. Default empty string. 266 * @return WP_Comment[]|int[]|int List of comments or number of found comments if `$count` argument is true. 267 */ 268 function get_comments( $args = '' ) { 269 $query = new WP_Comment_Query(); 270 return $query->query( $args ); 271 } 272 273 /** 274 * Retrieves all of the WordPress supported comment statuses. 275 * 276 * Comments have a limited set of valid status values, this provides the comment 277 * status values and descriptions. 278 * 279 * @since 2.7.0 280 * 281 * @return string[] List of comment status labels keyed by status. 282 */ 283 function get_comment_statuses() { 284 $status = array( 285 'hold' => __( 'Unapproved' ), 286 'approve' => _x( 'Approved', 'comment status' ), 287 'spam' => _x( 'Spam', 'comment status' ), 288 'trash' => _x( 'Trash', 'comment status' ), 289 ); 290 291 return $status; 292 } 293 294 /** 295 * Gets the default comment status for a post type. 296 * 297 * @since 4.3.0 298 * 299 * @param string $post_type Optional. Post type. Default 'post'. 300 * @param string $comment_type Optional. Comment type. Default 'comment'. 301 * @return string Either 'open' or 'closed'. 302 */ 303 function get_default_comment_status( $post_type = 'post', $comment_type = 'comment' ) { 304 switch ( $comment_type ) { 305 case 'pingback': 306 case 'trackback': 307 $supports = 'trackbacks'; 308 $option = 'ping'; 309 break; 310 default: 311 $supports = 'comments'; 312 $option = 'comment'; 313 break; 314 } 315 316 // Set the status. 317 if ( 'page' === $post_type ) { 318 $status = 'closed'; 319 } elseif ( post_type_supports( $post_type, $supports ) ) { 320 $status = get_option( "default_{$option}_status" ); 321 } else { 322 $status = 'closed'; 323 } 324 325 /** 326 * Filters the default comment status for the given post type. 327 * 328 * @since 4.3.0 329 * 330 * @param string $status Default status for the given post type, 331 * either 'open' or 'closed'. 332 * @param string $post_type Post type. Default is `post`. 333 * @param string $comment_type Type of comment. Default is `comment`. 334 */ 335 return apply_filters( 'get_default_comment_status', $status, $post_type, $comment_type ); 336 } 337 338 /** 339 * Retrieves the date the last comment was modified. 340 * 341 * @since 1.5.0 342 * @since 4.7.0 Replaced caching the modified date in a local static variable 343 * with the Object Cache API. 344 * 345 * @global wpdb $wpdb WordPress database abstraction object. 346 * 347 * @param string $timezone Which timezone to use in reference to 'gmt', 'blog', or 'server' locations. 348 * @return string|false Last comment modified date on success, false on failure. 349 */ 350 function get_lastcommentmodified( $timezone = 'server' ) { 351 global $wpdb; 352 353 $timezone = strtolower( $timezone ); 354 $key = "lastcommentmodified:$timezone"; 355 356 $comment_modified_date = wp_cache_get( $key, 'timeinfo' ); 357 if ( false !== $comment_modified_date ) { 358 return $comment_modified_date; 359 } 360 361 switch ( $timezone ) { 362 case 'gmt': 363 $comment_modified_date = $wpdb->get_var( "SELECT comment_date_gmt FROM $wpdb->comments WHERE comment_approved = '1' ORDER BY comment_date_gmt DESC LIMIT 1" ); 364 break; 365 case 'blog': 366 $comment_modified_date = $wpdb->get_var( "SELECT comment_date FROM $wpdb->comments WHERE comment_approved = '1' ORDER BY comment_date_gmt DESC LIMIT 1" ); 367 break; 368 case 'server': 369 $add_seconds_server = gmdate( 'Z' ); 370 371 $comment_modified_date = $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 ) ); 372 break; 373 } 374 375 if ( $comment_modified_date ) { 376 wp_cache_set( $key, $comment_modified_date, 'timeinfo' ); 377 378 return $comment_modified_date; 379 } 380 381 return false; 382 } 383 384 /** 385 * Retrieves the total comment counts for the whole site or a single post. 386 * 387 * @since 2.0.0 388 * 389 * @param int $post_id Optional. Restrict the comment counts to the given post. Default 0, which indicates that 390 * comment counts for the whole site will be retrieved. 391 * @return int[] { 392 * The number of comments keyed by their status. 393 * 394 * @type int $approved The number of approved comments. 395 * @type int $awaiting_moderation The number of comments awaiting moderation (a.k.a. pending). 396 * @type int $spam The number of spam comments. 397 * @type int $trash The number of trashed comments. 398 * @type int $post-trashed The number of comments for posts that are in the trash. 399 * @type int $total_comments The total number of non-trashed comments, including spam. 400 * @type int $all The total number of pending or approved comments. 401 * } 402 */ 403 function get_comment_count( $post_id = 0 ) { 404 $post_id = (int) $post_id; 405 406 $comment_count = array( 407 'approved' => 0, 408 'awaiting_moderation' => 0, 409 'spam' => 0, 410 'trash' => 0, 411 'post-trashed' => 0, 412 'total_comments' => 0, 413 'all' => 0, 414 ); 415 416 $args = array( 417 'count' => true, 418 'update_comment_meta_cache' => false, 419 'orderby' => 'none', 420 ); 421 if ( $post_id > 0 ) { 422 $args['post_id'] = $post_id; 423 } 424 $mapping = array( 425 'approved' => 'approve', 426 'awaiting_moderation' => 'hold', 427 'spam' => 'spam', 428 'trash' => 'trash', 429 'post-trashed' => 'post-trashed', 430 ); 431 $comment_count = array(); 432 foreach ( $mapping as $key => $value ) { 433 $comment_count[ $key ] = get_comments( array_merge( $args, array( 'status' => $value ) ) ); 434 } 435 436 $comment_count['all'] = $comment_count['approved'] + $comment_count['awaiting_moderation']; 437 $comment_count['total_comments'] = $comment_count['all'] + $comment_count['spam']; 438 439 return array_map( 'intval', $comment_count ); 440 } 441 442 // 443 // Comment meta functions. 444 // 445 446 /** 447 * Adds meta data field to a comment. 448 * 449 * @since 2.9.0 450 * 451 * @link https://developer.wordpress.org/reference/functions/add_comment_meta/ 452 * 453 * @param int $comment_id Comment ID. 454 * @param string $meta_key Metadata name. 455 * @param mixed $meta_value Metadata value. Arrays and objects are stored as serialized data and 456 * will be returned as the same type when retrieved. Other data types will 457 * be stored as strings in the database: 458 * - false is stored and retrieved as an empty string ('') 459 * - true is stored and retrieved as '1' 460 * - numbers (both integer and float) are stored and retrieved as strings 461 * Must be serializable if non-scalar. 462 * @param bool $unique Optional. Whether the same key should not be added. 463 * Default false. 464 * @return int|false Meta ID on success, false on failure. 465 */ 466 function add_comment_meta( $comment_id, $meta_key, $meta_value, $unique = false ) { 467 return add_metadata( 'comment', $comment_id, $meta_key, $meta_value, $unique ); 468 } 469 470 /** 471 * Removes metadata matching criteria from a comment. 472 * 473 * You can match based on the key, or key and value. Removing based on key and 474 * value, will keep from removing duplicate metadata with the same key. It also 475 * allows removing all metadata matching key, if needed. 476 * 477 * @since 2.9.0 478 * 479 * @link https://developer.wordpress.org/reference/functions/delete_comment_meta/ 480 * 481 * @param int $comment_id Comment ID. 482 * @param string $meta_key Metadata name. 483 * @param mixed $meta_value Optional. Metadata value. If provided, 484 * rows will only be removed that match the value. 485 * Must be serializable if non-scalar. Default empty string. 486 * @return bool True on success, false on failure. 487 */ 488 function delete_comment_meta( $comment_id, $meta_key, $meta_value = '' ) { 489 return delete_metadata( 'comment', $comment_id, $meta_key, $meta_value ); 490 } 491 492 /** 493 * Retrieves comment meta field for a comment. 494 * 495 * @since 2.9.0 496 * 497 * @link https://developer.wordpress.org/reference/functions/get_comment_meta/ 498 * 499 * @param int $comment_id Comment ID. 500 * @param string $key Optional. The meta key to retrieve. By default, 501 * returns data for all keys. Default empty string. 502 * @param bool $single Optional. Whether to return a single value. 503 * This parameter has no effect if `$key` is not specified. 504 * Default false. 505 * @return mixed An array of values if `$single` is false. 506 * The value of meta data field if `$single` is true. 507 * False for an invalid `$comment_id` (non-numeric, zero, or negative value). 508 * An empty array if a valid but non-existing comment ID is passed and `$single` is false. 509 * An empty string if a valid but non-existing comment ID is passed and `$single` is true. 510 * Note: Non-serialized values are returned as strings: 511 * - false values are returned as empty strings ('') 512 * - true values are returned as '1' 513 * - numbers are returned as strings 514 * Arrays and objects retain their original type. 515 */ 516 function get_comment_meta( $comment_id, $key = '', $single = false ) { 517 return get_metadata( 'comment', $comment_id, $key, $single ); 518 } 519 520 /** 521 * Queue comment meta for lazy-loading. 522 * 523 * @since 6.3.0 524 * 525 * @param array $comment_ids List of comment IDs. 526 */ 527 function wp_lazyload_comment_meta( array $comment_ids ) { 528 if ( empty( $comment_ids ) ) { 529 return; 530 } 531 $lazyloader = wp_metadata_lazyloader(); 532 $lazyloader->queue_objects( 'comment', $comment_ids ); 533 } 534 535 /** 536 * Updates comment meta field based on comment ID. 537 * 538 * Use the $prev_value parameter to differentiate between meta fields with the 539 * same key and comment ID. 540 * 541 * If the meta field for the comment does not exist, it will be added. 542 * 543 * @since 2.9.0 544 * 545 * @link https://developer.wordpress.org/reference/functions/update_comment_meta/ 546 * 547 * @param int $comment_id Comment ID. 548 * @param string $meta_key Metadata key. 549 * @param mixed $meta_value Metadata value. Must be serializable if non-scalar. 550 * @param mixed $prev_value Optional. Previous value to check before updating. 551 * If specified, only update existing metadata entries with 552 * this value. Otherwise, update all entries. Default empty string. 553 * @return int|bool Meta ID if the key didn't exist, true on successful update, 554 * false on failure or if the value passed to the function 555 * is the same as the one that is already in the database. 556 */ 557 function update_comment_meta( $comment_id, $meta_key, $meta_value, $prev_value = '' ) { 558 return update_metadata( 'comment', $comment_id, $meta_key, $meta_value, $prev_value ); 559 } 560 561 /** 562 * Sets the cookies used to store an unauthenticated commentator's identity. Typically used 563 * to recall previous comments by this commentator that are still held in moderation. 564 * 565 * @since 3.4.0 566 * @since 4.9.6 The `$cookies_consent` parameter was added. 567 * 568 * @param WP_Comment $comment Comment object. 569 * @param WP_User $user Comment author's user object. The user may not exist. 570 * @param bool $cookies_consent Optional. Comment author's consent to store cookies. Default true. 571 */ 572 function wp_set_comment_cookies( $comment, $user, $cookies_consent = true ) { 573 // If the user already exists, or the user opted out of cookies, don't set cookies. 574 if ( $user->exists() ) { 575 return; 576 } 577 578 if ( false === $cookies_consent ) { 579 // Remove any existing cookies. 580 $past = time() - YEAR_IN_SECONDS; 581 setcookie( 'comment_author_' . COOKIEHASH, ' ', $past, COOKIEPATH, COOKIE_DOMAIN ); 582 setcookie( 'comment_author_email_' . COOKIEHASH, ' ', $past, COOKIEPATH, COOKIE_DOMAIN ); 583 setcookie( 'comment_author_url_' . COOKIEHASH, ' ', $past, COOKIEPATH, COOKIE_DOMAIN ); 584 585 return; 586 } 587 588 /** 589 * Filters the lifetime of the comment cookie in seconds. 590 * 591 * @since 2.8.0 592 * @since 6.6.0 The default $seconds value changed from 30000000 to YEAR_IN_SECONDS. 593 * 594 * @param int $seconds Comment cookie lifetime. Default YEAR_IN_SECONDS. 595 */ 596 $comment_cookie_lifetime = time() + apply_filters( 'comment_cookie_lifetime', YEAR_IN_SECONDS ); 597 598 $secure = ( 'https' === parse_url( home_url(), PHP_URL_SCHEME ) ); 599 600 setcookie( 'comment_author_' . COOKIEHASH, $comment->comment_author, $comment_cookie_lifetime, COOKIEPATH, COOKIE_DOMAIN, $secure ); 601 setcookie( 'comment_author_email_' . COOKIEHASH, $comment->comment_author_email, $comment_cookie_lifetime, COOKIEPATH, COOKIE_DOMAIN, $secure ); 602 setcookie( 'comment_author_url_' . COOKIEHASH, esc_url( $comment->comment_author_url ), $comment_cookie_lifetime, COOKIEPATH, COOKIE_DOMAIN, $secure ); 603 } 604 605 /** 606 * Sanitizes the cookies sent to the user already. 607 * 608 * Will only do anything if the cookies have already been created for the user. 609 * Mostly used after cookies had been sent to use elsewhere. 610 * 611 * @since 2.0.4 612 */ 613 function sanitize_comment_cookies() { 614 if ( isset( $_COOKIE[ 'comment_author_' . COOKIEHASH ] ) ) { 615 /** 616 * Filters the comment author's name cookie before it is set. 617 * 618 * When this filter hook is evaluated in wp_filter_comment(), 619 * the comment author's name string is passed. 620 * 621 * @since 1.5.0 622 * 623 * @param string $author_cookie The comment author name cookie. 624 */ 625 $comment_author = apply_filters( 'pre_comment_author_name', $_COOKIE[ 'comment_author_' . COOKIEHASH ] ); 626 $comment_author = wp_unslash( $comment_author ); 627 $comment_author = esc_attr( $comment_author ); 628 629 $_COOKIE[ 'comment_author_' . COOKIEHASH ] = $comment_author; 630 } 631 632 if ( isset( $_COOKIE[ 'comment_author_email_' . COOKIEHASH ] ) ) { 633 /** 634 * Filters the comment author's email cookie before it is set. 635 * 636 * When this filter hook is evaluated in wp_filter_comment(), 637 * the comment author's email string is passed. 638 * 639 * @since 1.5.0 640 * 641 * @param string $author_email_cookie The comment author email cookie. 642 */ 643 $comment_author_email = apply_filters( 'pre_comment_author_email', $_COOKIE[ 'comment_author_email_' . COOKIEHASH ] ); 644 $comment_author_email = wp_unslash( $comment_author_email ); 645 $comment_author_email = esc_attr( $comment_author_email ); 646 647 $_COOKIE[ 'comment_author_email_' . COOKIEHASH ] = $comment_author_email; 648 } 649 650 if ( isset( $_COOKIE[ 'comment_author_url_' . COOKIEHASH ] ) ) { 651 /** 652 * Filters the comment author's URL cookie before it is set. 653 * 654 * When this filter hook is evaluated in wp_filter_comment(), 655 * the comment author's URL string is passed. 656 * 657 * @since 1.5.0 658 * 659 * @param string $author_url_cookie The comment author URL cookie. 660 */ 661 $comment_author_url = apply_filters( 'pre_comment_author_url', $_COOKIE[ 'comment_author_url_' . COOKIEHASH ] ); 662 $comment_author_url = wp_unslash( $comment_author_url ); 663 664 $_COOKIE[ 'comment_author_url_' . COOKIEHASH ] = $comment_author_url; 665 } 666 } 667 668 /** 669 * Validates whether this comment is allowed to be made. 670 * 671 * @since 2.0.0 672 * @since 4.7.0 The `$avoid_die` parameter was added, allowing the function 673 * to return a WP_Error object instead of dying. 674 * @since 5.5.0 The `$avoid_die` parameter was renamed to `$wp_error`. 675 * 676 * @global wpdb $wpdb WordPress database abstraction object. 677 * 678 * @param array $commentdata Contains information on the comment. 679 * @param bool $wp_error When true, a disallowed comment will result in the function 680 * returning a WP_Error object, rather than executing wp_die(). 681 * Default false. 682 * @return int|string|WP_Error Allowed comments return the approval status (0|1|'spam'|'trash'). 683 * If `$wp_error` is true, disallowed comments return a WP_Error. 684 */ 685 function wp_allow_comment( $commentdata, $wp_error = false ) { 686 global $wpdb; 687 688 /* 689 * Simple duplicate check. 690 * expected_slashed ($comment_post_ID, $comment_author, $comment_author_email, $comment_content) 691 */ 692 $dupe = $wpdb->prepare( 693 "SELECT comment_ID FROM $wpdb->comments WHERE comment_post_ID = %d AND comment_parent = %s AND comment_approved != 'trash' AND ( comment_author = %s ", 694 wp_unslash( $commentdata['comment_post_ID'] ), 695 wp_unslash( $commentdata['comment_parent'] ), 696 wp_unslash( $commentdata['comment_author'] ) 697 ); 698 if ( $commentdata['comment_author_email'] ) { 699 $dupe .= $wpdb->prepare( 700 'AND comment_author_email = %s ', 701 wp_unslash( $commentdata['comment_author_email'] ) 702 ); 703 } 704 $dupe .= $wpdb->prepare( 705 ') AND comment_content = %s LIMIT 1', 706 wp_unslash( $commentdata['comment_content'] ) 707 ); 708 709 $dupe_id = $wpdb->get_var( $dupe ); 710 711 /** 712 * Filters the ID, if any, of the duplicate comment found when creating a new comment. 713 * 714 * Return an empty value from this filter to allow what WP considers a duplicate comment. 715 * 716 * @since 4.4.0 717 * 718 * @param int $dupe_id ID of the comment identified as a duplicate. 719 * @param array $commentdata Data for the comment being created. 720 */ 721 $dupe_id = apply_filters( 'duplicate_comment_id', $dupe_id, $commentdata ); 722 723 if ( $dupe_id ) { 724 /** 725 * Fires immediately after a duplicate comment is detected. 726 * 727 * @since 3.0.0 728 * 729 * @param array $commentdata Comment data. 730 */ 731 do_action( 'comment_duplicate_trigger', $commentdata ); 732 733 /** 734 * Filters duplicate comment error message. 735 * 736 * @since 5.2.0 737 * 738 * @param string $comment_duplicate_message Duplicate comment error message. 739 */ 740 $comment_duplicate_message = apply_filters( 'comment_duplicate_message', __( 'Duplicate comment detected; it looks as though you’ve already said that!' ) ); 741 742 if ( $wp_error ) { 743 return new WP_Error( 'comment_duplicate', $comment_duplicate_message, 409 ); 744 } else { 745 if ( wp_doing_ajax() ) { 746 die( $comment_duplicate_message ); 747 } 748 749 wp_die( $comment_duplicate_message, 409 ); 750 } 751 } 752 753 /** 754 * Fires immediately before a comment is marked approved. 755 * 756 * Allows checking for comment flooding. 757 * 758 * @since 2.3.0 759 * @since 4.7.0 The `$avoid_die` parameter was added. 760 * @since 5.5.0 The `$avoid_die` parameter was renamed to `$wp_error`. 761 * 762 * @param string $comment_author_ip Comment author's IP address. 763 * @param string $comment_author_email Comment author's email. 764 * @param string $comment_date_gmt GMT date the comment was posted. 765 * @param bool $wp_error Whether to return a WP_Error object instead of executing 766 * wp_die() or die() if a comment flood is occurring. 767 */ 768 do_action( 769 'check_comment_flood', 770 $commentdata['comment_author_IP'], 771 $commentdata['comment_author_email'], 772 $commentdata['comment_date_gmt'], 773 $wp_error 774 ); 775 776 /** 777 * Filters whether a comment is part of a comment flood. 778 * 779 * The default check is wp_check_comment_flood(). See check_comment_flood_db(). 780 * 781 * @since 4.7.0 782 * @since 5.5.0 The `$avoid_die` parameter was renamed to `$wp_error`. 783 * 784 * @param bool $is_flood Is a comment flooding occurring? Default false. 785 * @param string $comment_author_ip Comment author's IP address. 786 * @param string $comment_author_email Comment author's email. 787 * @param string $comment_date_gmt GMT date the comment was posted. 788 * @param bool $wp_error Whether to return a WP_Error object instead of executing 789 * wp_die() or die() if a comment flood is occurring. 790 */ 791 $is_flood = apply_filters( 792 'wp_is_comment_flood', 793 false, 794 $commentdata['comment_author_IP'], 795 $commentdata['comment_author_email'], 796 $commentdata['comment_date_gmt'], 797 $wp_error 798 ); 799 800 if ( $is_flood ) { 801 /** This filter is documented in wp-includes/comment-template.php */ 802 $comment_flood_message = apply_filters( 'comment_flood_message', __( 'You are posting comments too quickly. Slow down.' ) ); 803 804 return new WP_Error( 'comment_flood', $comment_flood_message, 429 ); 805 } 806 807 return wp_check_comment_data( $commentdata ); 808 } 809 810 /** 811 * Hooks WP's native database-based comment-flood check. 812 * 813 * This wrapper maintains backward compatibility with plugins that expect to 814 * be able to unhook the legacy check_comment_flood_db() function from 815 * 'check_comment_flood' using remove_action(). 816 * 817 * @since 2.3.0 818 * @since 4.7.0 Converted to be an add_filter() wrapper. 819 */ 820 function check_comment_flood_db() { 821 add_filter( 'wp_is_comment_flood', 'wp_check_comment_flood', 10, 5 ); 822 } 823 824 /** 825 * Checks whether comment flooding is occurring. 826 * 827 * Won't run, if current user can manage options, so to not block 828 * administrators. 829 * 830 * @since 4.7.0 831 * 832 * @global wpdb $wpdb WordPress database abstraction object. 833 * 834 * @param bool $is_flood Is a comment flooding occurring? 835 * @param string $ip Comment author's IP address. 836 * @param string $email Comment author's email address. 837 * @param string $date MySQL time string. 838 * @param bool $avoid_die When true, a disallowed comment will result in the function 839 * returning without executing wp_die() or die(). Default false. 840 * @return bool Whether comment flooding is occurring. 841 */ 842 function wp_check_comment_flood( $is_flood, $ip, $email, $date, $avoid_die = false ) { 843 global $wpdb; 844 845 // Another callback has declared a flood. Trust it. 846 if ( true === $is_flood ) { 847 return $is_flood; 848 } 849 850 // Don't throttle admins or moderators. 851 if ( current_user_can( 'manage_options' ) || current_user_can( 'moderate_comments' ) ) { 852 return false; 853 } 854 855 $hour_ago = gmdate( 'Y-m-d H:i:s', time() - HOUR_IN_SECONDS ); 856 857 if ( is_user_logged_in() ) { 858 $user = get_current_user_id(); 859 $check_column = '`user_id`'; 860 } else { 861 $user = $ip; 862 $check_column = '`comment_author_IP`'; 863 } 864 865 $sql = $wpdb->prepare( 866 "SELECT `comment_date_gmt` FROM `$wpdb->comments` WHERE `comment_date_gmt` >= %s AND ( $check_column = %s OR `comment_author_email` = %s ) ORDER BY `comment_date_gmt` DESC LIMIT 1", 867 $hour_ago, 868 $user, 869 $email 870 ); 871 872 $lasttime = $wpdb->get_var( $sql ); 873 874 if ( $lasttime ) { 875 $time_lastcomment = mysql2date( 'U', $lasttime, false ); 876 $time_newcomment = mysql2date( 'U', $date, false ); 877 878 /** 879 * Filters the comment flood status. 880 * 881 * @since 2.1.0 882 * 883 * @param bool $bool Whether a comment flood is occurring. Default false. 884 * @param int $time_lastcomment Timestamp of when the last comment was posted. 885 * @param int $time_newcomment Timestamp of when the new comment was posted. 886 */ 887 $flood_die = apply_filters( 'comment_flood_filter', false, $time_lastcomment, $time_newcomment ); 888 889 if ( $flood_die ) { 890 /** 891 * Fires before the comment flood message is triggered. 892 * 893 * @since 1.5.0 894 * 895 * @param int $time_lastcomment Timestamp of when the last comment was posted. 896 * @param int $time_newcomment Timestamp of when the new comment was posted. 897 */ 898 do_action( 'comment_flood_trigger', $time_lastcomment, $time_newcomment ); 899 900 if ( $avoid_die ) { 901 return true; 902 } else { 903 /** 904 * Filters the comment flood error message. 905 * 906 * @since 5.2.0 907 * 908 * @param string $comment_flood_message Comment flood error message. 909 */ 910 $comment_flood_message = apply_filters( 'comment_flood_message', __( 'You are posting comments too quickly. Slow down.' ) ); 911 912 if ( wp_doing_ajax() ) { 913 die( $comment_flood_message ); 914 } 915 916 wp_die( $comment_flood_message, 429 ); 917 } 918 } 919 } 920 921 return false; 922 } 923 924 /** 925 * Separates an array of comments into an array keyed by comment_type. 926 * 927 * @since 2.7.0 928 * 929 * @param WP_Comment[] $comments Array of comments 930 * @return WP_Comment[] Array of comments keyed by comment_type. 931 */ 932 function separate_comments( &$comments ) { 933 $comments_by_type = array( 934 'comment' => array(), 935 'trackback' => array(), 936 'pingback' => array(), 937 'pings' => array(), 938 ); 939 940 $count = count( $comments ); 941 942 for ( $i = 0; $i < $count; $i++ ) { 943 $type = $comments[ $i ]->comment_type; 944 945 if ( empty( $type ) ) { 946 $type = 'comment'; 947 } 948 949 $comments_by_type[ $type ][] = &$comments[ $i ]; 950 951 if ( 'trackback' === $type || 'pingback' === $type ) { 952 $comments_by_type['pings'][] = &$comments[ $i ]; 953 } 954 } 955 956 return $comments_by_type; 957 } 958 959 /** 960 * Calculates the total number of comment pages. 961 * 962 * @since 2.7.0 963 * 964 * @uses Walker_Comment 965 * 966 * @global WP_Query $wp_query WordPress Query object. 967 * 968 * @param WP_Comment[] $comments Optional. Array of WP_Comment objects. Defaults to `$wp_query->comments`. 969 * @param int $per_page Optional. Comments per page. Defaults to the value of `comments_per_page` 970 * query var, option of the same name, or 1 (in that order). 971 * @param bool $threaded Optional. Control over flat or threaded comments. Defaults to the value 972 * of `thread_comments` option. 973 * @return int Number of comment pages. 974 */ 975 function get_comment_pages_count( $comments = null, $per_page = null, $threaded = null ) { 976 global $wp_query; 977 978 if ( null === $comments && null === $per_page && null === $threaded && ! empty( $wp_query->max_num_comment_pages ) ) { 979 return $wp_query->max_num_comment_pages; 980 } 981 982 if ( ( ! $comments || ! is_array( $comments ) ) && ! empty( $wp_query->comments ) ) { 983 $comments = $wp_query->comments; 984 } 985 986 if ( empty( $comments ) ) { 987 return 0; 988 } 989 990 if ( ! get_option( 'page_comments' ) ) { 991 return 1; 992 } 993 994 if ( ! isset( $per_page ) ) { 995 $per_page = (int) get_query_var( 'comments_per_page' ); 996 } 997 if ( 0 === $per_page ) { 998 $per_page = (int) get_option( 'comments_per_page' ); 999 } 1000 if ( 0 === $per_page ) { 1001 return 1; 1002 } 1003 1004 if ( ! isset( $threaded ) ) { 1005 $threaded = get_option( 'thread_comments' ); 1006 } 1007 1008 if ( $threaded ) { 1009 $walker = new Walker_Comment(); 1010 $count = ceil( $walker->get_number_of_root_elements( $comments ) / $per_page ); 1011 } else { 1012 $count = ceil( count( $comments ) / $per_page ); 1013 } 1014 1015 return (int) $count; 1016 } 1017 1018 /** 1019 * Calculates what page number a comment will appear on for comment paging. 1020 * 1021 * @since 2.7.0 1022 * 1023 * @global wpdb $wpdb WordPress database abstraction object. 1024 * 1025 * @param int $comment_id Comment ID. 1026 * @param array $args { 1027 * Array of optional arguments. 1028 * 1029 * @type string $type Limit paginated comments to those matching a given type. 1030 * Accepts 'comment', 'trackback', 'pingback', 'pings' 1031 * (trackbacks and pingbacks), or 'all'. Default 'all'. 1032 * @type int $per_page Per-page count to use when calculating pagination. 1033 * Defaults to the value of the 'comments_per_page' option. 1034 * @type int|string $max_depth If greater than 1, comment page will be determined 1035 * for the top-level parent `$comment_id`. 1036 * Defaults to the value of the 'thread_comments_depth' option. 1037 * } 1038 * @return int|null Comment page number or null on error. 1039 */ 1040 function get_page_of_comment( $comment_id, $args = array() ) { 1041 global $wpdb; 1042 1043 $page = null; 1044 1045 $comment = get_comment( $comment_id ); 1046 if ( ! $comment ) { 1047 return; 1048 } 1049 1050 $defaults = array( 1051 'type' => 'all', 1052 'page' => '', 1053 'per_page' => '', 1054 'max_depth' => '', 1055 ); 1056 $args = wp_parse_args( $args, $defaults ); 1057 $original_args = $args; 1058 1059 // Order of precedence: 1. `$args['per_page']`, 2. 'comments_per_page' query_var, 3. 'comments_per_page' option. 1060 if ( get_option( 'page_comments' ) ) { 1061 if ( '' === $args['per_page'] ) { 1062 $args['per_page'] = get_query_var( 'comments_per_page' ); 1063 } 1064 1065 if ( '' === $args['per_page'] ) { 1066 $args['per_page'] = get_option( 'comments_per_page' ); 1067 } 1068 } 1069 1070 if ( empty( $args['per_page'] ) ) { 1071 $args['per_page'] = 0; 1072 $args['page'] = 0; 1073 } 1074 1075 if ( $args['per_page'] < 1 ) { 1076 $page = 1; 1077 } 1078 1079 if ( null === $page ) { 1080 if ( '' === $args['max_depth'] ) { 1081 if ( get_option( 'thread_comments' ) ) { 1082 $args['max_depth'] = get_option( 'thread_comments_depth' ); 1083 } else { 1084 $args['max_depth'] = -1; 1085 } 1086 } 1087 1088 // Find this comment's top-level parent if threading is enabled. 1089 if ( $args['max_depth'] > 1 && '0' !== $comment->comment_parent ) { 1090 return get_page_of_comment( $comment->comment_parent, $args ); 1091 } 1092 1093 $comment_args = array( 1094 'type' => $args['type'], 1095 'post_id' => $comment->comment_post_ID, 1096 'fields' => 'ids', 1097 'count' => true, 1098 'status' => 'approve', 1099 'orderby' => 'none', 1100 'parent' => 0, 1101 'date_query' => array( 1102 array( 1103 'column' => "$wpdb->comments.comment_date_gmt", 1104 'before' => $comment->comment_date_gmt, 1105 ), 1106 ), 1107 ); 1108 1109 if ( is_user_logged_in() ) { 1110 $comment_args['include_unapproved'] = array( get_current_user_id() ); 1111 } else { 1112 $unapproved_email = wp_get_unapproved_comment_author_email(); 1113 1114 if ( $unapproved_email ) { 1115 $comment_args['include_unapproved'] = array( $unapproved_email ); 1116 } 1117 } 1118 1119 /** 1120 * Filters the arguments used to query comments in get_page_of_comment(). 1121 * 1122 * @since 5.5.0 1123 * 1124 * @see WP_Comment_Query::__construct() 1125 * 1126 * @param array $comment_args { 1127 * Array of WP_Comment_Query arguments. 1128 * 1129 * @type string $type Limit paginated comments to those matching a given type. 1130 * Accepts 'comment', 'trackback', 'pingback', 'pings' 1131 * (trackbacks and pingbacks), or 'all'. Default 'all'. 1132 * @type int $post_id ID of the post. 1133 * @type string $fields Comment fields to return. 1134 * @type bool $count Whether to return a comment count (true) or array 1135 * of comment objects (false). 1136 * @type string $status Comment status. 1137 * @type int $parent Parent ID of comment to retrieve children of. 1138 * @type array $date_query Date query clauses to limit comments by. See WP_Date_Query. 1139 * @type array $include_unapproved Array of IDs or email addresses whose unapproved comments 1140 * will be included in paginated comments. 1141 * } 1142 */ 1143 $comment_args = apply_filters( 'get_page_of_comment_query_args', $comment_args ); 1144 1145 $comment_query = new WP_Comment_Query(); 1146 $older_comment_count = $comment_query->query( $comment_args ); 1147 1148 // No older comments? Then it's page #1. 1149 if ( 0 === $older_comment_count ) { 1150 $page = 1; 1151 1152 // Divide comments older than this one by comments per page to get this comment's page number. 1153 } else { 1154 $page = (int) ceil( ( $older_comment_count + 1 ) / $args['per_page'] ); 1155 } 1156 } 1157 1158 /** 1159 * Filters the calculated page on which a comment appears. 1160 * 1161 * @since 4.4.0 1162 * @since 4.7.0 Introduced the `$comment_id` parameter. 1163 * 1164 * @param int $page Comment page. 1165 * @param array $args { 1166 * Arguments used to calculate pagination. These include arguments auto-detected by the function, 1167 * based on query vars, system settings, etc. For pristine arguments passed to the function, 1168 * see `$original_args`. 1169 * 1170 * @type string $type Type of comments to count. 1171 * @type int $page Calculated current page. 1172 * @type int $per_page Calculated number of comments per page. 1173 * @type int $max_depth Maximum comment threading depth allowed. 1174 * } 1175 * @param array $original_args { 1176 * Array of arguments passed to the function. Some or all of these may not be set. 1177 * 1178 * @type string $type Type of comments to count. 1179 * @type int $page Current comment page. 1180 * @type int $per_page Number of comments per page. 1181 * @type int $max_depth Maximum comment threading depth allowed. 1182 * } 1183 * @param int $comment_id ID of the comment. 1184 */ 1185 return apply_filters( 'get_page_of_comment', (int) $page, $args, $original_args, $comment_id ); 1186 } 1187 1188 /** 1189 * Retrieves the maximum character lengths for the comment form fields. 1190 * 1191 * @since 4.5.0 1192 * 1193 * @global wpdb $wpdb WordPress database abstraction object. 1194 * 1195 * @return int[] Array of maximum lengths keyed by field name. 1196 */ 1197 function wp_get_comment_fields_max_lengths() { 1198 global $wpdb; 1199 1200 $lengths = array( 1201 'comment_author' => 245, 1202 'comment_author_email' => 100, 1203 'comment_author_url' => 200, 1204 'comment_content' => 65525, 1205 ); 1206 1207 if ( $wpdb->is_mysql ) { 1208 foreach ( $lengths as $column => $length ) { 1209 $col_length = $wpdb->get_col_length( $wpdb->comments, $column ); 1210 $max_length = 0; 1211 1212 // No point if we can't get the DB column lengths. 1213 if ( is_wp_error( $col_length ) ) { 1214 break; 1215 } 1216 1217 if ( ! is_array( $col_length ) && (int) $col_length > 0 ) { 1218 $max_length = (int) $col_length; 1219 } elseif ( is_array( $col_length ) && isset( $col_length['length'] ) && (int) $col_length['length'] > 0 ) { 1220 $max_length = (int) $col_length['length']; 1221 1222 if ( ! empty( $col_length['type'] ) && 'byte' === $col_length['type'] ) { 1223 $max_length = $max_length - 10; 1224 } 1225 } 1226 1227 if ( $max_length > 0 ) { 1228 $lengths[ $column ] = $max_length; 1229 } 1230 } 1231 } 1232 1233 /** 1234 * Filters the lengths for the comment form fields. 1235 * 1236 * @since 4.5.0 1237 * 1238 * @param int[] $lengths Array of maximum lengths keyed by field name. 1239 */ 1240 return apply_filters( 'wp_get_comment_fields_max_lengths', $lengths ); 1241 } 1242 1243 /** 1244 * Compares the lengths of comment data against the maximum character limits. 1245 * 1246 * @since 4.7.0 1247 * 1248 * @param array $comment_data Array of arguments for inserting a comment. 1249 * @return WP_Error|true WP_Error when a comment field exceeds the limit, 1250 * otherwise true. 1251 */ 1252 function wp_check_comment_data_max_lengths( $comment_data ) { 1253 $max_lengths = wp_get_comment_fields_max_lengths(); 1254 1255 if ( isset( $comment_data['comment_author'] ) && mb_strlen( $comment_data['comment_author'], '8bit' ) > $max_lengths['comment_author'] ) { 1256 return new WP_Error( 'comment_author_column_length', __( '<strong>Error:</strong> Your name is too long.' ), 200 ); 1257 } 1258 1259 if ( isset( $comment_data['comment_author_email'] ) && strlen( $comment_data['comment_author_email'] ) > $max_lengths['comment_author_email'] ) { 1260 return new WP_Error( 'comment_author_email_column_length', __( '<strong>Error:</strong> Your email address is too long.' ), 200 ); 1261 } 1262 1263 if ( isset( $comment_data['comment_author_url'] ) && strlen( $comment_data['comment_author_url'] ) > $max_lengths['comment_author_url'] ) { 1264 return new WP_Error( 'comment_author_url_column_length', __( '<strong>Error:</strong> Your URL is too long.' ), 200 ); 1265 } 1266 1267 if ( isset( $comment_data['comment_content'] ) && mb_strlen( $comment_data['comment_content'], '8bit' ) > $max_lengths['comment_content'] ) { 1268 return new WP_Error( 'comment_content_column_length', __( '<strong>Error:</strong> Your comment is too long.' ), 200 ); 1269 } 1270 1271 return true; 1272 } 1273 1274 /** 1275 * Checks whether comment data passes internal checks or has disallowed content. 1276 * 1277 * @since 6.7.0 1278 * 1279 * @global wpdb $wpdb WordPress database abstraction object. 1280 * 1281 * @param array $comment_data Array of arguments for inserting a comment. 1282 * @return int|string|WP_Error The approval status on success (0|1|'spam'|'trash'), 1283 * WP_Error otherwise. 1284 */ 1285 function wp_check_comment_data( $comment_data ) { 1286 global $wpdb; 1287 1288 if ( ! empty( $comment_data['user_id'] ) ) { 1289 $user = get_userdata( $comment_data['user_id'] ); 1290 $post_author = (int) $wpdb->get_var( 1291 $wpdb->prepare( 1292 "SELECT post_author FROM $wpdb->posts WHERE ID = %d LIMIT 1", 1293 $comment_data['comment_post_ID'] 1294 ) 1295 ); 1296 } 1297 1298 if ( isset( $user ) && ( $comment_data['user_id'] === $post_author || $user->has_cap( 'moderate_comments' ) ) ) { 1299 // The author and the admins get respect. 1300 $approved = 1; 1301 } else { 1302 // Everyone else's comments will be checked. 1303 if ( check_comment( 1304 $comment_data['comment_author'], 1305 $comment_data['comment_author_email'], 1306 $comment_data['comment_author_url'], 1307 $comment_data['comment_content'], 1308 $comment_data['comment_author_IP'], 1309 $comment_data['comment_agent'], 1310 $comment_data['comment_type'] 1311 ) ) { 1312 $approved = 1; 1313 } else { 1314 $approved = 0; 1315 } 1316 1317 if ( wp_check_comment_disallowed_list( 1318 $comment_data['comment_author'], 1319 $comment_data['comment_author_email'], 1320 $comment_data['comment_author_url'], 1321 $comment_data['comment_content'], 1322 $comment_data['comment_author_IP'], 1323 $comment_data['comment_agent'] 1324 ) ) { 1325 $approved = EMPTY_TRASH_DAYS ? 'trash' : 'spam'; 1326 } 1327 } 1328 1329 /** 1330 * Filters a comment's approval status before it is set. 1331 * 1332 * @since 2.1.0 1333 * @since 4.9.0 Returning a WP_Error value from the filter will short-circuit comment insertion 1334 * and allow skipping further processing. 1335 * 1336 * @param int|string|WP_Error $approved The approval status. Accepts 1, 0, 'spam', 'trash', 1337 * or WP_Error. 1338 * @param array $commentdata Comment data. 1339 */ 1340 return apply_filters( 'pre_comment_approved', $approved, $comment_data ); 1341 } 1342 1343 /** 1344 * Checks if a comment contains disallowed characters or words. 1345 * 1346 * @since 5.5.0 1347 * 1348 * @param string $author The author of the comment. 1349 * @param string $email The email of the comment. 1350 * @param string $url The url used in the comment. 1351 * @param string $comment The comment content. 1352 * @param string $user_ip The comment author's IP address. 1353 * @param string $user_agent The author's browser user agent. 1354 * @return bool True if the comment contains disallowed content, false otherwise. 1355 */ 1356 function wp_check_comment_disallowed_list( $author, $email, $url, $comment, $user_ip, $user_agent ) { 1357 /** 1358 * Fires before the comment is tested for disallowed characters or words. 1359 * 1360 * @since 1.5.0 1361 * @deprecated 5.5.0 Use {@see 'wp_check_comment_disallowed_list'} instead. 1362 * 1363 * @param string $author Comment author. 1364 * @param string $email Comment author's email. 1365 * @param string $url Comment author's URL. 1366 * @param string $comment Comment content. 1367 * @param string $user_ip Comment author's IP address. 1368 * @param string $user_agent Comment author's browser user agent. 1369 */ 1370 do_action_deprecated( 1371 'wp_blacklist_check', 1372 array( $author, $email, $url, $comment, $user_ip, $user_agent ), 1373 '5.5.0', 1374 'wp_check_comment_disallowed_list', 1375 __( 'Please consider writing more inclusive code.' ) 1376 ); 1377 1378 /** 1379 * Fires before the comment is tested for disallowed characters or words. 1380 * 1381 * @since 5.5.0 1382 * 1383 * @param string $author Comment author. 1384 * @param string $email Comment author's email. 1385 * @param string $url Comment author's URL. 1386 * @param string $comment Comment content. 1387 * @param string $user_ip Comment author's IP address. 1388 * @param string $user_agent Comment author's browser user agent. 1389 */ 1390 do_action( 'wp_check_comment_disallowed_list', $author, $email, $url, $comment, $user_ip, $user_agent ); 1391 1392 $mod_keys = trim( get_option( 'disallowed_keys' ) ); 1393 if ( '' === $mod_keys ) { 1394 return false; // If moderation keys are empty. 1395 } 1396 1397 // Ensure HTML tags are not being used to bypass the list of disallowed characters and words. 1398 $comment_without_html = wp_strip_all_tags( $comment ); 1399 1400 $words = explode( "\n", $mod_keys ); 1401 1402 foreach ( (array) $words as $word ) { 1403 $word = trim( $word ); 1404 1405 // Skip empty lines. 1406 if ( empty( $word ) ) { 1407 continue; } 1408 1409 // Do some escaping magic so that '#' chars in the spam words don't break things: 1410 $word = preg_quote( $word, '#' ); 1411 1412 $pattern = "#$word#iu"; 1413 if ( preg_match( $pattern, $author ) 1414 || preg_match( $pattern, $email ) 1415 || preg_match( $pattern, $url ) 1416 || preg_match( $pattern, $comment ) 1417 || preg_match( $pattern, $comment_without_html ) 1418 || preg_match( $pattern, $user_ip ) 1419 || preg_match( $pattern, $user_agent ) 1420 ) { 1421 return true; 1422 } 1423 } 1424 return false; 1425 } 1426 1427 /** 1428 * Retrieves the total comment counts for the whole site or a single post. 1429 * 1430 * The comment stats are cached and then retrieved, if they already exist in the 1431 * cache. 1432 * 1433 * @see get_comment_count() Which handles fetching the live comment counts. 1434 * 1435 * @since 2.5.0 1436 * 1437 * @param int $post_id Optional. Restrict the comment counts to the given post. Default 0, which indicates that 1438 * comment counts for the whole site will be retrieved. 1439 * @return stdClass { 1440 * The number of comments keyed by their status. 1441 * 1442 * @type int $approved The number of approved comments. 1443 * @type int $moderated The number of comments awaiting moderation (a.k.a. pending). 1444 * @type int $spam The number of spam comments. 1445 * @type int $trash The number of trashed comments. 1446 * @type int $post-trashed The number of comments for posts that are in the trash. 1447 * @type int $total_comments The total number of non-trashed comments, including spam. 1448 * @type int $all The total number of pending or approved comments. 1449 * } 1450 */ 1451 function wp_count_comments( $post_id = 0 ) { 1452 $post_id = (int) $post_id; 1453 1454 /** 1455 * Filters the comments count for a given post or the whole site. 1456 * 1457 * @since 2.7.0 1458 * 1459 * @param array|stdClass $count An empty array or an object containing comment counts. 1460 * @param int $post_id The post ID. Can be 0 to represent the whole site. 1461 */ 1462 $filtered = apply_filters( 'wp_count_comments', array(), $post_id ); 1463 if ( ! empty( $filtered ) ) { 1464 return $filtered; 1465 } 1466 1467 $count = wp_cache_get( "comments-{$post_id}", 'counts' ); 1468 if ( false !== $count ) { 1469 return $count; 1470 } 1471 1472 $stats = get_comment_count( $post_id ); 1473 $stats['moderated'] = $stats['awaiting_moderation']; 1474 unset( $stats['awaiting_moderation'] ); 1475 1476 $stats_object = (object) $stats; 1477 wp_cache_set( "comments-{$post_id}", $stats_object, 'counts' ); 1478 1479 return $stats_object; 1480 } 1481 1482 /** 1483 * Trashes or deletes a comment. 1484 * 1485 * The comment is moved to Trash instead of permanently deleted unless Trash is 1486 * disabled, item is already in the Trash, or $force_delete is true. 1487 * 1488 * The post comment count will be updated if the comment was approved and has a 1489 * post ID available. 1490 * 1491 * @since 2.0.0 1492 * 1493 * @global wpdb $wpdb WordPress database abstraction object. 1494 * 1495 * @param int|WP_Comment $comment_id Comment ID or WP_Comment object. 1496 * @param bool $force_delete Whether to bypass Trash and force deletion. Default false. 1497 * @return bool True on success, false on failure. 1498 */ 1499 function wp_delete_comment( $comment_id, $force_delete = false ) { 1500 global $wpdb; 1501 1502 $comment = get_comment( $comment_id ); 1503 if ( ! $comment ) { 1504 return false; 1505 } 1506 1507 if ( ! $force_delete && EMPTY_TRASH_DAYS && ! in_array( wp_get_comment_status( $comment ), array( 'trash', 'spam' ), true ) ) { 1508 return wp_trash_comment( $comment_id ); 1509 } 1510 1511 /** 1512 * Fires immediately before a comment is deleted from the database. 1513 * 1514 * @since 1.2.0 1515 * @since 4.9.0 Added the `$comment` parameter. 1516 * 1517 * @param string $comment_id The comment ID as a numeric string. 1518 * @param WP_Comment $comment The comment to be deleted. 1519 */ 1520 do_action( 'delete_comment', $comment->comment_ID, $comment ); 1521 1522 // Move children up a level. 1523 $children = $wpdb->get_col( $wpdb->prepare( "SELECT comment_ID FROM $wpdb->comments WHERE comment_parent = %d", $comment->comment_ID ) ); 1524 if ( ! empty( $children ) ) { 1525 $wpdb->update( $wpdb->comments, array( 'comment_parent' => $comment->comment_parent ), array( 'comment_parent' => $comment->comment_ID ) ); 1526 clean_comment_cache( $children ); 1527 } 1528 1529 // Delete metadata. 1530 $meta_ids = $wpdb->get_col( $wpdb->prepare( "SELECT meta_id FROM $wpdb->commentmeta WHERE comment_id = %d", $comment->comment_ID ) ); 1531 foreach ( $meta_ids as $mid ) { 1532 delete_metadata_by_mid( 'comment', $mid ); 1533 } 1534 1535 if ( ! $wpdb->delete( $wpdb->comments, array( 'comment_ID' => $comment->comment_ID ) ) ) { 1536 return false; 1537 } 1538 1539 /** 1540 * Fires immediately after a comment is deleted from the database. 1541 * 1542 * @since 2.9.0 1543 * @since 4.9.0 Added the `$comment` parameter. 1544 * 1545 * @param string $comment_id The comment ID as a numeric string. 1546 * @param WP_Comment $comment The deleted comment. 1547 */ 1548 do_action( 'deleted_comment', $comment->comment_ID, $comment ); 1549 1550 $post_id = $comment->comment_post_ID; 1551 if ( $post_id && '1' === $comment->comment_approved ) { 1552 wp_update_comment_count( $post_id ); 1553 } 1554 1555 clean_comment_cache( $comment->comment_ID ); 1556 1557 /** This action is documented in wp-includes/comment.php */ 1558 do_action( 'wp_set_comment_status', $comment->comment_ID, 'delete' ); 1559 1560 wp_transition_comment_status( 'delete', $comment->comment_approved, $comment ); 1561 1562 return true; 1563 } 1564 1565 /** 1566 * Moves a comment to the Trash 1567 * 1568 * If Trash is disabled, comment is permanently deleted. 1569 * 1570 * @since 2.9.0 1571 * 1572 * @param int|WP_Comment $comment_id Comment ID or WP_Comment object. 1573 * @return bool True on success, false on failure. 1574 */ 1575 function wp_trash_comment( $comment_id ) { 1576 if ( ! EMPTY_TRASH_DAYS ) { 1577 return wp_delete_comment( $comment_id, true ); 1578 } 1579 1580 $comment = get_comment( $comment_id ); 1581 if ( ! $comment ) { 1582 return false; 1583 } 1584 1585 /** 1586 * Fires immediately before a comment is sent to the Trash. 1587 * 1588 * @since 2.9.0 1589 * @since 4.9.0 Added the `$comment` parameter. 1590 * 1591 * @param string $comment_id The comment ID as a numeric string. 1592 * @param WP_Comment $comment The comment to be trashed. 1593 */ 1594 do_action( 'trash_comment', $comment->comment_ID, $comment ); 1595 1596 if ( wp_set_comment_status( $comment, 'trash' ) ) { 1597 delete_comment_meta( $comment->comment_ID, '_wp_trash_meta_status' ); 1598 delete_comment_meta( $comment->comment_ID, '_wp_trash_meta_time' ); 1599 add_comment_meta( $comment->comment_ID, '_wp_trash_meta_status', $comment->comment_approved ); 1600 add_comment_meta( $comment->comment_ID, '_wp_trash_meta_time', time() ); 1601 1602 /** 1603 * Fires immediately after a comment is sent to Trash. 1604 * 1605 * @since 2.9.0 1606 * @since 4.9.0 Added the `$comment` parameter. 1607 * 1608 * @param string $comment_id The comment ID as a numeric string. 1609 * @param WP_Comment $comment The trashed comment. 1610 */ 1611 do_action( 'trashed_comment', $comment->comment_ID, $comment ); 1612 1613 return true; 1614 } 1615 1616 return false; 1617 } 1618 1619 /** 1620 * Removes a comment from the Trash 1621 * 1622 * @since 2.9.0 1623 * 1624 * @param int|WP_Comment $comment_id Comment ID or WP_Comment object. 1625 * @return bool True on success, false on failure. 1626 */ 1627 function wp_untrash_comment( $comment_id ) { 1628 $comment = get_comment( $comment_id ); 1629 if ( ! $comment ) { 1630 return false; 1631 } 1632 1633 /** 1634 * Fires immediately before a comment is restored from the Trash. 1635 * 1636 * @since 2.9.0 1637 * @since 4.9.0 Added the `$comment` parameter. 1638 * 1639 * @param string $comment_id The comment ID as a numeric string. 1640 * @param WP_Comment $comment The comment to be untrashed. 1641 */ 1642 do_action( 'untrash_comment', $comment->comment_ID, $comment ); 1643 1644 $status = (string) get_comment_meta( $comment->comment_ID, '_wp_trash_meta_status', true ); 1645 if ( empty( $status ) ) { 1646 $status = '0'; 1647 } 1648 1649 if ( wp_set_comment_status( $comment, $status ) ) { 1650 delete_comment_meta( $comment->comment_ID, '_wp_trash_meta_time' ); 1651 delete_comment_meta( $comment->comment_ID, '_wp_trash_meta_status' ); 1652 1653 /** 1654 * Fires immediately after a comment is restored from the Trash. 1655 * 1656 * @since 2.9.0 1657 * @since 4.9.0 Added the `$comment` parameter. 1658 * 1659 * @param string $comment_id The comment ID as a numeric string. 1660 * @param WP_Comment $comment The untrashed comment. 1661 */ 1662 do_action( 'untrashed_comment', $comment->comment_ID, $comment ); 1663 1664 return true; 1665 } 1666 1667 return false; 1668 } 1669 1670 /** 1671 * Marks a comment as Spam. 1672 * 1673 * @since 2.9.0 1674 * 1675 * @param int|WP_Comment $comment_id Comment ID or WP_Comment object. 1676 * @return bool True on success, false on failure. 1677 */ 1678 function wp_spam_comment( $comment_id ) { 1679 $comment = get_comment( $comment_id ); 1680 if ( ! $comment ) { 1681 return false; 1682 } 1683 1684 /** 1685 * Fires immediately before a comment is marked as Spam. 1686 * 1687 * @since 2.9.0 1688 * @since 4.9.0 Added the `$comment` parameter. 1689 * 1690 * @param int $comment_id The comment ID. 1691 * @param WP_Comment $comment The comment to be marked as spam. 1692 */ 1693 do_action( 'spam_comment', $comment->comment_ID, $comment ); 1694 1695 if ( wp_set_comment_status( $comment, 'spam' ) ) { 1696 delete_comment_meta( $comment->comment_ID, '_wp_trash_meta_status' ); 1697 delete_comment_meta( $comment->comment_ID, '_wp_trash_meta_time' ); 1698 add_comment_meta( $comment->comment_ID, '_wp_trash_meta_status', $comment->comment_approved ); 1699 add_comment_meta( $comment->comment_ID, '_wp_trash_meta_time', time() ); 1700 1701 /** 1702 * Fires immediately after a comment is marked as Spam. 1703 * 1704 * @since 2.9.0 1705 * @since 4.9.0 Added the `$comment` parameter. 1706 * 1707 * @param int $comment_id The comment ID. 1708 * @param WP_Comment $comment The comment marked as spam. 1709 */ 1710 do_action( 'spammed_comment', $comment->comment_ID, $comment ); 1711 1712 return true; 1713 } 1714 1715 return false; 1716 } 1717 1718 /** 1719 * Removes a comment from the Spam. 1720 * 1721 * @since 2.9.0 1722 * 1723 * @param int|WP_Comment $comment_id Comment ID or WP_Comment object. 1724 * @return bool True on success, false on failure. 1725 */ 1726 function wp_unspam_comment( $comment_id ) { 1727 $comment = get_comment( $comment_id ); 1728 if ( ! $comment ) { 1729 return false; 1730 } 1731 1732 /** 1733 * Fires immediately before a comment is unmarked as Spam. 1734 * 1735 * @since 2.9.0 1736 * @since 4.9.0 Added the `$comment` parameter. 1737 * 1738 * @param string $comment_id The comment ID as a numeric string. 1739 * @param WP_Comment $comment The comment to be unmarked as spam. 1740 */ 1741 do_action( 'unspam_comment', $comment->comment_ID, $comment ); 1742 1743 $status = (string) get_comment_meta( $comment->comment_ID, '_wp_trash_meta_status', true ); 1744 if ( empty( $status ) ) { 1745 $status = '0'; 1746 } 1747 1748 if ( wp_set_comment_status( $comment, $status ) ) { 1749 delete_comment_meta( $comment->comment_ID, '_wp_trash_meta_status' ); 1750 delete_comment_meta( $comment->comment_ID, '_wp_trash_meta_time' ); 1751 1752 /** 1753 * Fires immediately after a comment is unmarked as Spam. 1754 * 1755 * @since 2.9.0 1756 * @since 4.9.0 Added the `$comment` parameter. 1757 * 1758 * @param string $comment_id The comment ID as a numeric string. 1759 * @param WP_Comment $comment The comment unmarked as spam. 1760 */ 1761 do_action( 'unspammed_comment', $comment->comment_ID, $comment ); 1762 1763 return true; 1764 } 1765 1766 return false; 1767 } 1768 1769 /** 1770 * Retrieves the status of a comment by comment ID. 1771 * 1772 * @since 1.0.0 1773 * 1774 * @param int|WP_Comment $comment_id Comment ID or WP_Comment object 1775 * @return string|false Status might be 'trash', 'approved', 'unapproved', 'spam'. False on failure. 1776 */ 1777 function wp_get_comment_status( $comment_id ) { 1778 $comment = get_comment( $comment_id ); 1779 if ( ! $comment ) { 1780 return false; 1781 } 1782 1783 $approved = $comment->comment_approved; 1784 1785 if ( null === $approved ) { 1786 return false; 1787 } elseif ( '1' === $approved ) { 1788 return 'approved'; 1789 } elseif ( '0' === $approved ) { 1790 return 'unapproved'; 1791 } elseif ( 'spam' === $approved ) { 1792 return 'spam'; 1793 } elseif ( 'trash' === $approved ) { 1794 return 'trash'; 1795 } else { 1796 return false; 1797 } 1798 } 1799 1800 /** 1801 * Calls hooks for when a comment status transition occurs. 1802 * 1803 * Calls hooks for comment status transitions. If the new comment status is not the same 1804 * as the previous comment status, then two hooks will be ran, the first is 1805 * {@see 'transition_comment_status'} with new status, old status, and comment data. 1806 * The next action called is {@see 'comment_$old_status_to_$new_status'}. It has 1807 * the comment data. 1808 * 1809 * The final action will run whether or not the comment statuses are the same. 1810 * The action is named {@see 'comment_$new_status_$comment->comment_type'}. 1811 * 1812 * @since 2.7.0 1813 * 1814 * @param string $new_status New comment status. 1815 * @param string $old_status Previous comment status. 1816 * @param WP_Comment $comment Comment object. 1817 */ 1818 function wp_transition_comment_status( $new_status, $old_status, $comment ) { 1819 /* 1820 * Translate raw statuses to human-readable formats for the hooks. 1821 * This is not a complete list of comment status, it's only the ones 1822 * that need to be renamed. 1823 */ 1824 $comment_statuses = array( 1825 0 => 'unapproved', 1826 'hold' => 'unapproved', // wp_set_comment_status() uses "hold". 1827 1 => 'approved', 1828 'approve' => 'approved', // wp_set_comment_status() uses "approve". 1829 ); 1830 if ( isset( $comment_statuses[ $new_status ] ) ) { 1831 $new_status = $comment_statuses[ $new_status ]; 1832 } 1833 if ( isset( $comment_statuses[ $old_status ] ) ) { 1834 $old_status = $comment_statuses[ $old_status ]; 1835 } 1836 1837 // Call the hooks. 1838 if ( $new_status !== $old_status ) { 1839 /** 1840 * Fires when the comment status is in transition. 1841 * 1842 * @since 2.7.0 1843 * 1844 * @param string $new_status The new comment status. 1845 * @param string $old_status The old comment status. 1846 * @param WP_Comment $comment Comment object. 1847 */ 1848 do_action( 'transition_comment_status', $new_status, $old_status, $comment ); 1849 1850 /** 1851 * Fires when the comment status is in transition from one specific status to another. 1852 * 1853 * The dynamic portions of the hook name, `$old_status`, and `$new_status`, 1854 * refer to the old and new comment statuses, respectively. 1855 * 1856 * Possible hook names include: 1857 * 1858 * - `comment_unapproved_to_approved` 1859 * - `comment_spam_to_approved` 1860 * - `comment_approved_to_unapproved` 1861 * - `comment_spam_to_unapproved` 1862 * - `comment_unapproved_to_spam` 1863 * - `comment_approved_to_spam` 1864 * 1865 * @since 2.7.0 1866 * 1867 * @param WP_Comment $comment Comment object. 1868 */ 1869 do_action( "comment_{$old_status}_to_{$new_status}", $comment ); 1870 } 1871 /** 1872 * Fires when the status of a specific comment type is in transition. 1873 * 1874 * The dynamic portions of the hook name, `$new_status`, and `$comment->comment_type`, 1875 * refer to the new comment status, and the type of comment, respectively. 1876 * 1877 * Typical comment types include 'comment', 'pingback', or 'trackback'. 1878 * 1879 * Possible hook names include: 1880 * 1881 * - `comment_approved_comment` 1882 * - `comment_approved_pingback` 1883 * - `comment_approved_trackback` 1884 * - `comment_unapproved_comment` 1885 * - `comment_unapproved_pingback` 1886 * - `comment_unapproved_trackback` 1887 * - `comment_spam_comment` 1888 * - `comment_spam_pingback` 1889 * - `comment_spam_trackback` 1890 * 1891 * @since 2.7.0 1892 * 1893 * @param string $comment_id The comment ID as a numeric string. 1894 * @param WP_Comment $comment Comment object. 1895 */ 1896 do_action( "comment_{$new_status}_{$comment->comment_type}", $comment->comment_ID, $comment ); 1897 } 1898 1899 /** 1900 * Clears the lastcommentmodified cached value when a comment status is changed. 1901 * 1902 * Deletes the lastcommentmodified cache key when a comment enters or leaves 1903 * 'approved' status. 1904 * 1905 * @since 4.7.0 1906 * @access private 1907 * 1908 * @param string $new_status The new comment status. 1909 * @param string $old_status The old comment status. 1910 */ 1911 function _clear_modified_cache_on_transition_comment_status( $new_status, $old_status ) { 1912 if ( 'approved' === $new_status || 'approved' === $old_status ) { 1913 $data = array(); 1914 foreach ( array( 'server', 'gmt', 'blog' ) as $timezone ) { 1915 $data[] = "lastcommentmodified:$timezone"; 1916 } 1917 wp_cache_delete_multiple( $data, 'timeinfo' ); 1918 } 1919 } 1920 1921 /** 1922 * Gets current commenter's name, email, and URL. 1923 * 1924 * Expects cookies content to already be sanitized. User of this function might 1925 * wish to recheck the returned array for validity. 1926 * 1927 * @see sanitize_comment_cookies() Use to sanitize cookies 1928 * 1929 * @since 2.0.4 1930 * 1931 * @return array { 1932 * An array of current commenter variables. 1933 * 1934 * @type string $comment_author The name of the current commenter, or an empty string. 1935 * @type string $comment_author_email The email address of the current commenter, or an empty string. 1936 * @type string $comment_author_url The URL address of the current commenter, or an empty string. 1937 * } 1938 */ 1939 function wp_get_current_commenter() { 1940 // Cookies should already be sanitized. 1941 1942 $comment_author = ''; 1943 if ( isset( $_COOKIE[ 'comment_author_' . COOKIEHASH ] ) ) { 1944 $comment_author = $_COOKIE[ 'comment_author_' . COOKIEHASH ]; 1945 } 1946 1947 $comment_author_email = ''; 1948 if ( isset( $_COOKIE[ 'comment_author_email_' . COOKIEHASH ] ) ) { 1949 $comment_author_email = $_COOKIE[ 'comment_author_email_' . COOKIEHASH ]; 1950 } 1951 1952 $comment_author_url = ''; 1953 if ( isset( $_COOKIE[ 'comment_author_url_' . COOKIEHASH ] ) ) { 1954 $comment_author_url = $_COOKIE[ 'comment_author_url_' . COOKIEHASH ]; 1955 } 1956 1957 /** 1958 * Filters the current commenter's name, email, and URL. 1959 * 1960 * @since 3.1.0 1961 * 1962 * @param array $comment_author_data { 1963 * An array of current commenter variables. 1964 * 1965 * @type string $comment_author The name of the current commenter, or an empty string. 1966 * @type string $comment_author_email The email address of the current commenter, or an empty string. 1967 * @type string $comment_author_url The URL address of the current commenter, or an empty string. 1968 * } 1969 */ 1970 return apply_filters( 'wp_get_current_commenter', compact( 'comment_author', 'comment_author_email', 'comment_author_url' ) ); 1971 } 1972 1973 /** 1974 * Gets unapproved comment author's email. 1975 * 1976 * Used to allow the commenter to see their pending comment. 1977 * 1978 * @since 5.1.0 1979 * @since 5.7.0 The window within which the author email for an unapproved comment 1980 * can be retrieved was extended to 10 minutes. 1981 * 1982 * @return string The unapproved comment author's email (when supplied). 1983 */ 1984 function wp_get_unapproved_comment_author_email() { 1985 $commenter_email = ''; 1986 1987 if ( ! empty( $_GET['unapproved'] ) && ! empty( $_GET['moderation-hash'] ) ) { 1988 $comment_id = (int) $_GET['unapproved']; 1989 $comment = get_comment( $comment_id ); 1990 1991 if ( $comment && hash_equals( $_GET['moderation-hash'], wp_hash( $comment->comment_date_gmt ) ) ) { 1992 // The comment will only be viewable by the comment author for 10 minutes. 1993 $comment_preview_expires = strtotime( $comment->comment_date_gmt . '+10 minutes' ); 1994 1995 if ( time() < $comment_preview_expires ) { 1996 $commenter_email = $comment->comment_author_email; 1997 } 1998 } 1999 } 2000 2001 if ( ! $commenter_email ) { 2002 $commenter = wp_get_current_commenter(); 2003 $commenter_email = $commenter['comment_author_email']; 2004 } 2005 2006 return $commenter_email; 2007 } 2008 2009 /** 2010 * Inserts a comment into the database. 2011 * 2012 * @since 2.0.0 2013 * @since 4.4.0 Introduced the `$comment_meta` argument. 2014 * @since 5.5.0 Default value for `$comment_type` argument changed to `comment`. 2015 * 2016 * @global wpdb $wpdb WordPress database abstraction object. 2017 * 2018 * @param array $commentdata { 2019 * Array of arguments for inserting a new comment. 2020 * 2021 * @type string $comment_agent The HTTP user agent of the `$comment_author` when 2022 * the comment was submitted. Default empty. 2023 * @type int|string $comment_approved Whether the comment has been approved. Default 1. 2024 * @type string $comment_author The name of the author of the comment. Default empty. 2025 * @type string $comment_author_email The email address of the `$comment_author`. Default empty. 2026 * @type string $comment_author_IP The IP address of the `$comment_author`. Default empty. 2027 * @type string $comment_author_url The URL address of the `$comment_author`. Default empty. 2028 * @type string $comment_content The content of the comment. Default empty. 2029 * @type string $comment_date The date the comment was submitted. To set the date 2030 * manually, `$comment_date_gmt` must also be specified. 2031 * Default is the current time. 2032 * @type string $comment_date_gmt The date the comment was submitted in the GMT timezone. 2033 * Default is `$comment_date` in the site's GMT timezone. 2034 * @type int $comment_karma The karma of the comment. Default 0. 2035 * @type int $comment_parent ID of this comment's parent, if any. Default 0. 2036 * @type int $comment_post_ID ID of the post that relates to the comment, if any. 2037 * Default 0. 2038 * @type string $comment_type Comment type. Default 'comment'. 2039 * @type array $comment_meta Optional. Array of key/value pairs to be stored in commentmeta for the 2040 * new comment. 2041 * @type int $user_id ID of the user who submitted the comment. Default 0. 2042 * } 2043 * @return int|false The new comment's ID on success, false on failure. 2044 */ 2045 function wp_insert_comment( $commentdata ) { 2046 global $wpdb; 2047 2048 $data = wp_unslash( $commentdata ); 2049 2050 $comment_author = ! isset( $data['comment_author'] ) ? '' : $data['comment_author']; 2051 $comment_author_email = ! isset( $data['comment_author_email'] ) ? '' : $data['comment_author_email']; 2052 $comment_author_url = ! isset( $data['comment_author_url'] ) ? '' : $data['comment_author_url']; 2053 $comment_author_ip = ! isset( $data['comment_author_IP'] ) ? '' : $data['comment_author_IP']; 2054 2055 $comment_date = ! isset( $data['comment_date'] ) ? current_time( 'mysql' ) : $data['comment_date']; 2056 $comment_date_gmt = ! isset( $data['comment_date_gmt'] ) ? get_gmt_from_date( $comment_date ) : $data['comment_date_gmt']; 2057 2058 $comment_post_id = ! isset( $data['comment_post_ID'] ) ? 0 : $data['comment_post_ID']; 2059 $comment_content = ! isset( $data['comment_content'] ) ? '' : $data['comment_content']; 2060 $comment_karma = ! isset( $data['comment_karma'] ) ? 0 : $data['comment_karma']; 2061 $comment_approved = ! isset( $data['comment_approved'] ) ? 1 : $data['comment_approved']; 2062 $comment_agent = ! isset( $data['comment_agent'] ) ? '' : $data['comment_agent']; 2063 $comment_type = empty( $data['comment_type'] ) ? 'comment' : $data['comment_type']; 2064 $comment_parent = ! isset( $data['comment_parent'] ) ? 0 : $data['comment_parent']; 2065 2066 $user_id = ! isset( $data['user_id'] ) ? 0 : $data['user_id']; 2067 2068 $compacted = array( 2069 'comment_post_ID' => $comment_post_id, 2070 'comment_author_IP' => $comment_author_ip, 2071 ); 2072 2073 $compacted += compact( 2074 'comment_author', 2075 'comment_author_email', 2076 'comment_author_url', 2077 'comment_date', 2078 'comment_date_gmt', 2079 'comment_content', 2080 'comment_karma', 2081 'comment_approved', 2082 'comment_agent', 2083 'comment_type', 2084 'comment_parent', 2085 'user_id' 2086 ); 2087 2088 if ( ! $wpdb->insert( $wpdb->comments, $compacted ) ) { 2089 return false; 2090 } 2091 2092 $id = (int) $wpdb->insert_id; 2093 2094 if ( 1 === (int) $comment_approved ) { 2095 wp_update_comment_count( $comment_post_id ); 2096 2097 $data = array(); 2098 foreach ( array( 'server', 'gmt', 'blog' ) as $timezone ) { 2099 $data[] = "lastcommentmodified:$timezone"; 2100 } 2101 wp_cache_delete_multiple( $data, 'timeinfo' ); 2102 } 2103 2104 clean_comment_cache( $id ); 2105 2106 $comment = get_comment( $id ); 2107 2108 // If metadata is provided, store it. 2109 if ( isset( $commentdata['comment_meta'] ) && is_array( $commentdata['comment_meta'] ) ) { 2110 foreach ( $commentdata['comment_meta'] as $meta_key => $meta_value ) { 2111 add_comment_meta( $comment->comment_ID, $meta_key, $meta_value, true ); 2112 } 2113 } 2114 2115 /** 2116 * Fires immediately after a comment is inserted into the database. 2117 * 2118 * @since 2.8.0 2119 * 2120 * @param int $id The comment ID. 2121 * @param WP_Comment $comment Comment object. 2122 */ 2123 do_action( 'wp_insert_comment', $id, $comment ); 2124 2125 return $id; 2126 } 2127 2128 /** 2129 * Filters and sanitizes comment data. 2130 * 2131 * Sets the comment data 'filtered' field to true when finished. This can be 2132 * checked as to whether the comment should be filtered and to keep from 2133 * filtering the same comment more than once. 2134 * 2135 * @since 2.0.0 2136 * 2137 * @param array $commentdata Contains information on the comment. 2138 * @return array Parsed comment information. 2139 */ 2140 function wp_filter_comment( $commentdata ) { 2141 if ( isset( $commentdata['user_ID'] ) ) { 2142 /** 2143 * Filters the comment author's user ID before it is set. 2144 * 2145 * The first time this filter is evaluated, `user_ID` is checked 2146 * (for back-compat), followed by the standard `user_id` value. 2147 * 2148 * @since 1.5.0 2149 * 2150 * @param int $user_id The comment author's user ID. 2151 */ 2152 $commentdata['user_id'] = apply_filters( 'pre_user_id', $commentdata['user_ID'] ); 2153 } elseif ( isset( $commentdata['user_id'] ) ) { 2154 /** This filter is documented in wp-includes/comment.php */ 2155 $commentdata['user_id'] = apply_filters( 'pre_user_id', $commentdata['user_id'] ); 2156 } 2157 2158 /** 2159 * Filters the comment author's browser user agent before it is set. 2160 * 2161 * @since 1.5.0 2162 * 2163 * @param string $comment_agent The comment author's browser user agent. 2164 */ 2165 $commentdata['comment_agent'] = apply_filters( 'pre_comment_user_agent', ( isset( $commentdata['comment_agent'] ) ? $commentdata['comment_agent'] : '' ) ); 2166 /** This filter is documented in wp-includes/comment.php */ 2167 $commentdata['comment_author'] = apply_filters( 'pre_comment_author_name', $commentdata['comment_author'] ); 2168 /** 2169 * Filters the comment content before it is set. 2170 * 2171 * @since 1.5.0 2172 * 2173 * @param string $comment_content The comment content. 2174 */ 2175 $commentdata['comment_content'] = apply_filters( 'pre_comment_content', $commentdata['comment_content'] ); 2176 /** 2177 * Filters the comment author's IP address before it is set. 2178 * 2179 * @since 1.5.0 2180 * 2181 * @param string $comment_author_ip The comment author's IP address. 2182 */ 2183 $commentdata['comment_author_IP'] = apply_filters( 'pre_comment_user_ip', $commentdata['comment_author_IP'] ); 2184 /** This filter is documented in wp-includes/comment.php */ 2185 $commentdata['comment_author_url'] = apply_filters( 'pre_comment_author_url', $commentdata['comment_author_url'] ); 2186 /** This filter is documented in wp-includes/comment.php */ 2187 $commentdata['comment_author_email'] = apply_filters( 'pre_comment_author_email', $commentdata['comment_author_email'] ); 2188 2189 $commentdata['filtered'] = true; 2190 2191 return $commentdata; 2192 } 2193 2194 /** 2195 * Determines whether a comment should be blocked because of comment flood. 2196 * 2197 * @since 2.1.0 2198 * 2199 * @param bool $block Whether plugin has already blocked comment. 2200 * @param int $time_lastcomment Timestamp for last comment. 2201 * @param int $time_newcomment Timestamp for new comment. 2202 * @return bool Whether comment should be blocked. 2203 */ 2204 function wp_throttle_comment_flood( $block, $time_lastcomment, $time_newcomment ) { 2205 if ( $block ) { // A plugin has already blocked... we'll let that decision stand. 2206 return $block; 2207 } 2208 if ( ( $time_newcomment - $time_lastcomment ) < 15 ) { 2209 return true; 2210 } 2211 return false; 2212 } 2213 2214 /** 2215 * Adds a new comment to the database. 2216 * 2217 * Filters new comment to ensure that the fields are sanitized and valid before 2218 * inserting comment into database. Calls {@see 'comment_post'} action with comment ID 2219 * and whether comment is approved by WordPress. Also has {@see 'preprocess_comment'} 2220 * filter for processing the comment data before the function handles it. 2221 * 2222 * We use `REMOTE_ADDR` here directly. If you are behind a proxy, you should ensure 2223 * that it is properly set, such as in wp-config.php, for your environment. 2224 * 2225 * See {@link https://core.trac.wordpress.org/ticket/9235} 2226 * 2227 * @since 1.5.0 2228 * @since 4.3.0 Introduced the `comment_agent` and `comment_author_IP` arguments. 2229 * @since 4.7.0 The `$avoid_die` parameter was added, allowing the function 2230 * to return a WP_Error object instead of dying. 2231 * @since 5.5.0 The `$avoid_die` parameter was renamed to `$wp_error`. 2232 * @since 5.5.0 Introduced the `comment_type` argument. 2233 * 2234 * @see wp_insert_comment() 2235 * @global wpdb $wpdb WordPress database abstraction object. 2236 * 2237 * @param array $commentdata { 2238 * Comment data. 2239 * 2240 * @type string $comment_author The name of the comment author. 2241 * @type string $comment_author_email The comment author email address. 2242 * @type string $comment_author_url The comment author URL. 2243 * @type string $comment_content The content of the comment. 2244 * @type string $comment_date The date the comment was submitted. Default is the current time. 2245 * @type string $comment_date_gmt The date the comment was submitted in the GMT timezone. 2246 * Default is `$comment_date` in the GMT timezone. 2247 * @type string $comment_type Comment type. Default 'comment'. 2248 * @type int $comment_parent The ID of this comment's parent, if any. Default 0. 2249 * @type int $comment_post_ID The ID of the post that relates to the comment. 2250 * @type int $user_id The ID of the user who submitted the comment. Default 0. 2251 * @type int $user_ID Kept for backward-compatibility. Use `$user_id` instead. 2252 * @type string $comment_agent Comment author user agent. Default is the value of 'HTTP_USER_AGENT' 2253 * in the `$_SERVER` superglobal sent in the original request. 2254 * @type string $comment_author_IP Comment author IP address in IPv4 format. Default is the value of 2255 * 'REMOTE_ADDR' in the `$_SERVER` superglobal sent in the original request. 2256 * } 2257 * @param bool $wp_error Should errors be returned as WP_Error objects instead of 2258 * executing wp_die()? Default false. 2259 * @return int|false|WP_Error The ID of the comment on success, false or WP_Error on failure. 2260 */ 2261 function wp_new_comment( $commentdata, $wp_error = false ) { 2262 global $wpdb; 2263 2264 /* 2265 * Normalize `user_ID` to `user_id`, but pass the old key 2266 * to the `preprocess_comment` filter for backward compatibility. 2267 */ 2268 if ( isset( $commentdata['user_ID'] ) ) { 2269 $commentdata['user_ID'] = (int) $commentdata['user_ID']; 2270 $commentdata['user_id'] = $commentdata['user_ID']; 2271 } elseif ( isset( $commentdata['user_id'] ) ) { 2272 $commentdata['user_id'] = (int) $commentdata['user_id']; 2273 $commentdata['user_ID'] = $commentdata['user_id']; 2274 } 2275 2276 $prefiltered_user_id = ( isset( $commentdata['user_id'] ) ) ? (int) $commentdata['user_id'] : 0; 2277 2278 if ( ! isset( $commentdata['comment_author_IP'] ) ) { 2279 $commentdata['comment_author_IP'] = $_SERVER['REMOTE_ADDR']; 2280 } 2281 2282 if ( ! isset( $commentdata['comment_agent'] ) ) { 2283 $commentdata['comment_agent'] = isset( $_SERVER['HTTP_USER_AGENT'] ) ? $_SERVER['HTTP_USER_AGENT'] : ''; 2284 } 2285 2286 /** 2287 * Filters a comment's data before it is sanitized and inserted into the database. 2288 * 2289 * @since 1.5.0 2290 * @since 5.6.0 Comment data includes the `comment_agent` and `comment_author_IP` values. 2291 * 2292 * @param array $commentdata Comment data. 2293 */ 2294 $commentdata = apply_filters( 'preprocess_comment', $commentdata ); 2295 2296 $commentdata['comment_post_ID'] = (int) $commentdata['comment_post_ID']; 2297 2298 // Normalize `user_ID` to `user_id` again, after the filter. 2299 if ( isset( $commentdata['user_ID'] ) && $prefiltered_user_id !== (int) $commentdata['user_ID'] ) { 2300 $commentdata['user_ID'] = (int) $commentdata['user_ID']; 2301 $commentdata['user_id'] = $commentdata['user_ID']; 2302 } elseif ( isset( $commentdata['user_id'] ) ) { 2303 $commentdata['user_id'] = (int) $commentdata['user_id']; 2304 $commentdata['user_ID'] = $commentdata['user_id']; 2305 } 2306 2307 $commentdata['comment_parent'] = isset( $commentdata['comment_parent'] ) ? absint( $commentdata['comment_parent'] ) : 0; 2308 2309 $parent_status = ( $commentdata['comment_parent'] > 0 ) ? wp_get_comment_status( $commentdata['comment_parent'] ) : ''; 2310 2311 $commentdata['comment_parent'] = ( 'approved' === $parent_status || 'unapproved' === $parent_status ) ? $commentdata['comment_parent'] : 0; 2312 2313 $commentdata['comment_author_IP'] = preg_replace( '/[^0-9a-fA-F:., ]/', '', $commentdata['comment_author_IP'] ); 2314 2315 $commentdata['comment_agent'] = substr( $commentdata['comment_agent'], 0, 254 ); 2316 2317 if ( empty( $commentdata['comment_date'] ) ) { 2318 $commentdata['comment_date'] = current_time( 'mysql' ); 2319 } 2320 2321 if ( empty( $commentdata['comment_date_gmt'] ) ) { 2322 $commentdata['comment_date_gmt'] = current_time( 'mysql', 1 ); 2323 } 2324 2325 if ( empty( $commentdata['comment_type'] ) ) { 2326 $commentdata['comment_type'] = 'comment'; 2327 } 2328 2329 $commentdata['comment_approved'] = wp_allow_comment( $commentdata, $wp_error ); 2330 2331 if ( is_wp_error( $commentdata['comment_approved'] ) ) { 2332 return $commentdata['comment_approved']; 2333 } 2334 2335 $commentdata = wp_filter_comment( $commentdata ); 2336 2337 if ( ! in_array( $commentdata['comment_approved'], array( 'trash', 'spam' ), true ) ) { 2338 // Validate the comment again after filters are applied to comment data. 2339 $commentdata['comment_approved'] = wp_check_comment_data( $commentdata ); 2340 } 2341 2342 if ( is_wp_error( $commentdata['comment_approved'] ) ) { 2343 return $commentdata['comment_approved']; 2344 } 2345 2346 $comment_id = wp_insert_comment( $commentdata ); 2347 2348 if ( ! $comment_id ) { 2349 $fields = array( 'comment_author', 'comment_author_email', 'comment_author_url', 'comment_content' ); 2350 2351 foreach ( $fields as $field ) { 2352 if ( isset( $commentdata[ $field ] ) ) { 2353 $commentdata[ $field ] = $wpdb->strip_invalid_text_for_column( $wpdb->comments, $field, $commentdata[ $field ] ); 2354 } 2355 } 2356 2357 $commentdata = wp_filter_comment( $commentdata ); 2358 2359 $commentdata['comment_approved'] = wp_allow_comment( $commentdata, $wp_error ); 2360 if ( is_wp_error( $commentdata['comment_approved'] ) ) { 2361 return $commentdata['comment_approved']; 2362 } 2363 2364 $comment_id = wp_insert_comment( $commentdata ); 2365 if ( ! $comment_id ) { 2366 return false; 2367 } 2368 } 2369 2370 /** 2371 * Fires immediately after a comment is inserted into the database. 2372 * 2373 * @since 1.2.0 2374 * @since 4.5.0 The `$commentdata` parameter was added. 2375 * 2376 * @param int $comment_id The comment ID. 2377 * @param int|string $comment_approved 1 if the comment is approved, 0 if not, 'spam' if spam. 2378 * @param array $commentdata Comment data. 2379 */ 2380 do_action( 'comment_post', $comment_id, $commentdata['comment_approved'], $commentdata ); 2381 2382 return $comment_id; 2383 } 2384 2385 /** 2386 * Sends a comment moderation notification to the comment moderator. 2387 * 2388 * @since 4.4.0 2389 * 2390 * @param int $comment_id ID of the comment. 2391 * @return bool True on success, false on failure. 2392 */ 2393 function wp_new_comment_notify_moderator( $comment_id ) { 2394 $comment = get_comment( $comment_id ); 2395 2396 // Only send notifications for pending comments. 2397 $maybe_notify = ( '0' === $comment->comment_approved ); 2398 2399 /** This filter is documented in wp-includes/pluggable.php */ 2400 $maybe_notify = apply_filters( 'notify_moderator', $maybe_notify, $comment_id ); 2401 2402 if ( ! $maybe_notify ) { 2403 return false; 2404 } 2405 2406 return wp_notify_moderator( $comment_id ); 2407 } 2408 2409 /** 2410 * Sends a notification of a new comment to the post author. 2411 * 2412 * @since 4.4.0 2413 * 2414 * Uses the {@see 'notify_post_author'} filter to determine whether the post author 2415 * should be notified when a new comment is added, overriding site setting. 2416 * 2417 * @param int $comment_id Comment ID. 2418 * @return bool True on success, false on failure. 2419 */ 2420 function wp_new_comment_notify_postauthor( $comment_id ) { 2421 $comment = get_comment( $comment_id ); 2422 2423 $maybe_notify = get_option( 'comments_notify' ); 2424 2425 /** 2426 * Filters whether to send the post author new comment notification emails, 2427 * overriding the site setting. 2428 * 2429 * @since 4.4.0 2430 * 2431 * @param bool $maybe_notify Whether to notify the post author about the new comment. 2432 * @param int $comment_id The ID of the comment for the notification. 2433 */ 2434 $maybe_notify = apply_filters( 'notify_post_author', $maybe_notify, $comment_id ); 2435 2436 /* 2437 * wp_notify_postauthor() checks if notifying the author of their own comment. 2438 * By default, it won't, but filters can override this. 2439 */ 2440 if ( ! $maybe_notify ) { 2441 return false; 2442 } 2443 2444 // Only send notifications for approved comments. 2445 if ( ! isset( $comment->comment_approved ) || '1' !== $comment->comment_approved ) { 2446 return false; 2447 } 2448 2449 return wp_notify_postauthor( $comment_id ); 2450 } 2451 2452 /** 2453 * Sets the status of a comment. 2454 * 2455 * The {@see 'wp_set_comment_status'} action is called after the comment is handled. 2456 * If the comment status is not in the list, then false is returned. 2457 * 2458 * @since 1.0.0 2459 * 2460 * @global wpdb $wpdb WordPress database abstraction object. 2461 * 2462 * @param int|WP_Comment $comment_id Comment ID or WP_Comment object. 2463 * @param string $comment_status New comment status, either 'hold', 'approve', 'spam', or 'trash'. 2464 * @param bool $wp_error Whether to return a WP_Error object if there is a failure. Default false. 2465 * @return bool|WP_Error True on success, false or WP_Error on failure. 2466 */ 2467 function wp_set_comment_status( $comment_id, $comment_status, $wp_error = false ) { 2468 global $wpdb; 2469 2470 switch ( $comment_status ) { 2471 case 'hold': 2472 case '0': 2473 $status = '0'; 2474 break; 2475 case 'approve': 2476 case '1': 2477 $status = '1'; 2478 add_action( 'wp_set_comment_status', 'wp_new_comment_notify_postauthor' ); 2479 break; 2480 case 'spam': 2481 $status = 'spam'; 2482 break; 2483 case 'trash': 2484 $status = 'trash'; 2485 break; 2486 default: 2487 return false; 2488 } 2489 2490 $comment_old = clone get_comment( $comment_id ); 2491 2492 if ( ! $wpdb->update( $wpdb->comments, array( 'comment_approved' => $status ), array( 'comment_ID' => $comment_old->comment_ID ) ) ) { 2493 if ( $wp_error ) { 2494 return new WP_Error( 'db_update_error', __( 'Could not update comment status.' ), $wpdb->last_error ); 2495 } else { 2496 return false; 2497 } 2498 } 2499 2500 clean_comment_cache( $comment_old->comment_ID ); 2501 2502 $comment = get_comment( $comment_old->comment_ID ); 2503 2504 /** 2505 * Fires immediately after transitioning a comment's status from one to another in the database 2506 * and removing the comment from the object cache, but prior to all status transition hooks. 2507 * 2508 * @since 1.5.0 2509 * 2510 * @param string $comment_id Comment ID as a numeric string. 2511 * @param string $comment_status Current comment status. Possible values include 2512 * 'hold', '0', 'approve', '1', 'spam', and 'trash'. 2513 */ 2514 do_action( 'wp_set_comment_status', $comment->comment_ID, $comment_status ); 2515 2516 wp_transition_comment_status( $comment_status, $comment_old->comment_approved, $comment ); 2517 2518 wp_update_comment_count( $comment->comment_post_ID ); 2519 2520 return true; 2521 } 2522 2523 /** 2524 * Updates an existing comment in the database. 2525 * 2526 * Filters the comment and makes sure certain fields are valid before updating. 2527 * 2528 * @since 2.0.0 2529 * @since 4.9.0 Add updating comment meta during comment update. 2530 * @since 5.5.0 The `$wp_error` parameter was added. 2531 * @since 5.5.0 The return values for an invalid comment or post ID 2532 * were changed to false instead of 0. 2533 * 2534 * @global wpdb $wpdb WordPress database abstraction object. 2535 * 2536 * @param array $commentarr Contains information on the comment. 2537 * @param bool $wp_error Optional. Whether to return a WP_Error on failure. Default false. 2538 * @return int|false|WP_Error The value 1 if the comment was updated, 0 if not updated. 2539 * False or a WP_Error object on failure. 2540 */ 2541 function wp_update_comment( $commentarr, $wp_error = false ) { 2542 global $wpdb; 2543 2544 // First, get all of the original fields. 2545 $comment = get_comment( $commentarr['comment_ID'], ARRAY_A ); 2546 2547 if ( empty( $comment ) ) { 2548 if ( $wp_error ) { 2549 return new WP_Error( 'invalid_comment_id', __( 'Invalid comment ID.' ) ); 2550 } else { 2551 return false; 2552 } 2553 } 2554 2555 // Make sure that the comment post ID is valid (if specified). 2556 if ( ! empty( $commentarr['comment_post_ID'] ) && ! get_post( $commentarr['comment_post_ID'] ) ) { 2557 if ( $wp_error ) { 2558 return new WP_Error( 'invalid_post_id', __( 'Invalid post ID.' ) ); 2559 } else { 2560 return false; 2561 } 2562 } 2563 2564 $filter_comment = false; 2565 if ( ! has_filter( 'pre_comment_content', 'wp_filter_kses' ) ) { 2566 $filter_comment = ! user_can( isset( $comment['user_id'] ) ? $comment['user_id'] : 0, 'unfiltered_html' ); 2567 } 2568 2569 if ( $filter_comment ) { 2570 add_filter( 'pre_comment_content', 'wp_filter_kses' ); 2571 } 2572 2573 // Escape data pulled from DB. 2574 $comment = wp_slash( $comment ); 2575 2576 $old_status = $comment['comment_approved']; 2577 2578 // Merge old and new fields with new fields overwriting old ones. 2579 $commentarr = array_merge( $comment, $commentarr ); 2580 2581 $commentarr = wp_filter_comment( $commentarr ); 2582 2583 if ( $filter_comment ) { 2584 remove_filter( 'pre_comment_content', 'wp_filter_kses' ); 2585 } 2586 2587 // Now extract the merged array. 2588 $data = wp_unslash( $commentarr ); 2589 2590 /** 2591 * Filters the comment content before it is updated in the database. 2592 * 2593 * @since 1.5.0 2594 * 2595 * @param string $comment_content The comment data. 2596 */ 2597 $data['comment_content'] = apply_filters( 'comment_save_pre', $data['comment_content'] ); 2598 2599 $data['comment_date_gmt'] = get_gmt_from_date( $data['comment_date'] ); 2600 2601 if ( ! isset( $data['comment_approved'] ) ) { 2602 $data['comment_approved'] = 1; 2603 } elseif ( 'hold' === $data['comment_approved'] ) { 2604 $data['comment_approved'] = 0; 2605 } elseif ( 'approve' === $data['comment_approved'] ) { 2606 $data['comment_approved'] = 1; 2607 } 2608 2609 $comment_id = $data['comment_ID']; 2610 $comment_post_id = $data['comment_post_ID']; 2611 2612 /** 2613 * Filters the comment data immediately before it is updated in the database. 2614 * 2615 * Note: data being passed to the filter is already unslashed. 2616 * 2617 * @since 4.7.0 2618 * @since 5.5.0 Returning a WP_Error value from the filter will short-circuit comment update 2619 * and allow skipping further processing. 2620 * 2621 * @param array|WP_Error $data The new, processed comment data, or WP_Error. 2622 * @param array $comment The old, unslashed comment data. 2623 * @param array $commentarr The new, raw comment data. 2624 */ 2625 $data = apply_filters( 'wp_update_comment_data', $data, $comment, $commentarr ); 2626 2627 // Do not carry on on failure. 2628 if ( is_wp_error( $data ) ) { 2629 if ( $wp_error ) { 2630 return $data; 2631 } else { 2632 return false; 2633 } 2634 } 2635 2636 $keys = array( 2637 'comment_post_ID', 2638 'comment_author', 2639 'comment_author_email', 2640 'comment_author_url', 2641 'comment_author_IP', 2642 'comment_date', 2643 'comment_date_gmt', 2644 'comment_content', 2645 'comment_karma', 2646 'comment_approved', 2647 'comment_agent', 2648 'comment_type', 2649 'comment_parent', 2650 'user_id', 2651 ); 2652 2653 $data = wp_array_slice_assoc( $data, $keys ); 2654 2655 $result = $wpdb->update( $wpdb->comments, $data, array( 'comment_ID' => $comment_id ) ); 2656 2657 if ( false === $result ) { 2658 if ( $wp_error ) { 2659 return new WP_Error( 'db_update_error', __( 'Could not update comment in the database.' ), $wpdb->last_error ); 2660 } else { 2661 return false; 2662 } 2663 } 2664 2665 // If metadata is provided, store it. 2666 if ( isset( $commentarr['comment_meta'] ) && is_array( $commentarr['comment_meta'] ) ) { 2667 foreach ( $commentarr['comment_meta'] as $meta_key => $meta_value ) { 2668 update_comment_meta( $comment_id, $meta_key, $meta_value ); 2669 } 2670 } 2671 2672 clean_comment_cache( $comment_id ); 2673 wp_update_comment_count( $comment_post_id ); 2674 2675 /** 2676 * Fires immediately after a comment is updated in the database. 2677 * 2678 * The hook also fires immediately before comment status transition hooks are fired. 2679 * 2680 * @since 1.2.0 2681 * @since 4.6.0 Added the `$data` parameter. 2682 * 2683 * @param int $comment_id The comment ID. 2684 * @param array $data Comment data. 2685 */ 2686 do_action( 'edit_comment', $comment_id, $data ); 2687 2688 $comment = get_comment( $comment_id ); 2689 2690 wp_transition_comment_status( $comment->comment_approved, $old_status, $comment ); 2691 2692 return $result; 2693 } 2694 2695 /** 2696 * Determines whether to defer comment counting. 2697 * 2698 * When setting $defer to true, all post comment counts will not be updated 2699 * until $defer is set to false. When $defer is set to false, then all 2700 * previously deferred updated post comment counts will then be automatically 2701 * updated without having to call wp_update_comment_count() after. 2702 * 2703 * @since 2.5.0 2704 * 2705 * @param bool $defer 2706 * @return bool 2707 */ 2708 function wp_defer_comment_counting( $defer = null ) { 2709 static $_defer = false; 2710 2711 if ( is_bool( $defer ) ) { 2712 $_defer = $defer; 2713 // Flush any deferred counts. 2714 if ( ! $defer ) { 2715 wp_update_comment_count( null, true ); 2716 } 2717 } 2718 2719 return $_defer; 2720 } 2721 2722 /** 2723 * Updates the comment count for post(s). 2724 * 2725 * When $do_deferred is false (is by default) and the comments have been set to 2726 * be deferred, the post_id will be added to a queue, which will be updated at a 2727 * later date and only updated once per post ID. 2728 * 2729 * If the comments have not be set up to be deferred, then the post will be 2730 * updated. When $do_deferred is set to true, then all previous deferred post 2731 * IDs will be updated along with the current $post_id. 2732 * 2733 * @since 2.1.0 2734 * 2735 * @see wp_update_comment_count_now() For what could cause a false return value 2736 * 2737 * @param int|null $post_id Post ID. 2738 * @param bool $do_deferred Optional. Whether to process previously deferred 2739 * post comment counts. Default false. 2740 * @return bool|void True on success, false on failure or if post with ID does 2741 * not exist. 2742 */ 2743 function wp_update_comment_count( $post_id, $do_deferred = false ) { 2744 static $_deferred = array(); 2745 2746 if ( empty( $post_id ) && ! $do_deferred ) { 2747 return false; 2748 } 2749 2750 if ( $do_deferred ) { 2751 $_deferred = array_unique( $_deferred ); 2752 foreach ( $_deferred as $i => $_post_id ) { 2753 wp_update_comment_count_now( $_post_id ); 2754 unset( $_deferred[ $i ] ); 2755 /** @todo Move this outside of the foreach and reset $_deferred to an array instead */ 2756 } 2757 } 2758 2759 if ( wp_defer_comment_counting() ) { 2760 $_deferred[] = $post_id; 2761 return true; 2762 } elseif ( $post_id ) { 2763 return wp_update_comment_count_now( $post_id ); 2764 } 2765 } 2766 2767 /** 2768 * Updates the comment count for the post. 2769 * 2770 * @since 2.5.0 2771 * 2772 * @global wpdb $wpdb WordPress database abstraction object. 2773 * 2774 * @param int $post_id Post ID 2775 * @return bool True on success, false if the post does not exist. 2776 */ 2777 function wp_update_comment_count_now( $post_id ) { 2778 global $wpdb; 2779 2780 $post_id = (int) $post_id; 2781 2782 if ( ! $post_id ) { 2783 return false; 2784 } 2785 2786 wp_cache_delete( 'comments-0', 'counts' ); 2787 wp_cache_delete( "comments-{$post_id}", 'counts' ); 2788 2789 $post = get_post( $post_id ); 2790 2791 if ( ! $post ) { 2792 return false; 2793 } 2794 2795 $old = (int) $post->comment_count; 2796 2797 /** 2798 * Filters a post's comment count before it is updated in the database. 2799 * 2800 * @since 4.5.0 2801 * 2802 * @param int|null $new The new comment count. Default null. 2803 * @param int $old The old comment count. 2804 * @param int $post_id Post ID. 2805 */ 2806 $new = apply_filters( 'pre_wp_update_comment_count_now', null, $old, $post_id ); 2807 2808 if ( is_null( $new ) ) { 2809 $new = (int) $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(*) FROM $wpdb->comments WHERE comment_post_ID = %d AND comment_approved = '1'", $post_id ) ); 2810 } else { 2811 $new = (int) $new; 2812 } 2813 2814 $wpdb->update( $wpdb->posts, array( 'comment_count' => $new ), array( 'ID' => $post_id ) ); 2815 2816 clean_post_cache( $post ); 2817 2818 /** 2819 * Fires immediately after a post's comment count is updated in the database. 2820 * 2821 * @since 2.3.0 2822 * 2823 * @param int $post_id Post ID. 2824 * @param int $new The new comment count. 2825 * @param int $old The old comment count. 2826 */ 2827 do_action( 'wp_update_comment_count', $post_id, $new, $old ); 2828 2829 /** This action is documented in wp-includes/post.php */ 2830 do_action( "edit_post_{$post->post_type}", $post_id, $post ); 2831 2832 /** This action is documented in wp-includes/post.php */ 2833 do_action( 'edit_post', $post_id, $post ); 2834 2835 return true; 2836 } 2837 2838 // 2839 // Ping and trackback functions. 2840 // 2841 2842 /** 2843 * Finds a pingback server URI based on the given URL. 2844 * 2845 * Checks the HTML for the rel="pingback" link and X-Pingback headers. It does 2846 * a check for the X-Pingback headers first and returns that, if available. 2847 * The check for the rel="pingback" has more overhead than just the header. 2848 * 2849 * @since 1.5.0 2850 * 2851 * @param string $url URL to ping. 2852 * @param string $deprecated Not Used. 2853 * @return string|false String containing URI on success, false on failure. 2854 */ 2855 function discover_pingback_server_uri( $url, $deprecated = '' ) { 2856 if ( ! empty( $deprecated ) ) { 2857 _deprecated_argument( __FUNCTION__, '2.7.0' ); 2858 } 2859 2860 $pingback_str_dquote = 'rel="pingback"'; 2861 $pingback_str_squote = 'rel=\'pingback\''; 2862 2863 /** @todo Should use Filter Extension or custom preg_match instead. */ 2864 $parsed_url = parse_url( $url ); 2865 2866 if ( ! isset( $parsed_url['host'] ) ) { // Not a URL. This should never happen. 2867 return false; 2868 } 2869 2870 // Do not search for a pingback server on our own uploads. 2871 $uploads_dir = wp_get_upload_dir(); 2872 if ( str_starts_with( $url, $uploads_dir['baseurl'] ) ) { 2873 return false; 2874 } 2875 2876 $response = wp_safe_remote_head( 2877 $url, 2878 array( 2879 'timeout' => 2, 2880 'httpversion' => '1.0', 2881 ) 2882 ); 2883 2884 if ( is_wp_error( $response ) ) { 2885 return false; 2886 } 2887 2888 if ( wp_remote_retrieve_header( $response, 'X-Pingback' ) ) { 2889 return wp_remote_retrieve_header( $response, 'X-Pingback' ); 2890 } 2891 2892 // Not an (x)html, sgml, or xml page, no use going further. 2893 if ( preg_match( '#(image|audio|video|model)/#is', wp_remote_retrieve_header( $response, 'Content-Type' ) ) ) { 2894 return false; 2895 } 2896 2897 // Now do a GET since we're going to look in the HTML headers (and we're sure it's not a binary file). 2898 $response = wp_safe_remote_get( 2899 $url, 2900 array( 2901 'timeout' => 2, 2902 'httpversion' => '1.0', 2903 ) 2904 ); 2905 2906 if ( is_wp_error( $response ) ) { 2907 return false; 2908 } 2909 2910 $contents = wp_remote_retrieve_body( $response ); 2911 2912 $pingback_link_offset_dquote = strpos( $contents, $pingback_str_dquote ); 2913 $pingback_link_offset_squote = strpos( $contents, $pingback_str_squote ); 2914 2915 if ( $pingback_link_offset_dquote || $pingback_link_offset_squote ) { 2916 $quote = ( $pingback_link_offset_dquote ) ? '"' : '\''; 2917 $pingback_link_offset = ( '"' === $quote ) ? $pingback_link_offset_dquote : $pingback_link_offset_squote; 2918 $pingback_href_pos = strpos( $contents, 'href=', $pingback_link_offset ); 2919 $pingback_href_start = $pingback_href_pos + 6; 2920 $pingback_href_end = strpos( $contents, $quote, $pingback_href_start ); 2921 $pingback_server_url_len = $pingback_href_end - $pingback_href_start; 2922 $pingback_server_url = substr( $contents, $pingback_href_start, $pingback_server_url_len ); 2923 2924 // We may find rel="pingback" but an incomplete pingback URL. 2925 if ( $pingback_server_url_len > 0 ) { // We got it! 2926 return $pingback_server_url; 2927 } 2928 } 2929 2930 return false; 2931 } 2932 2933 /** 2934 * Performs all pingbacks, enclosures, trackbacks, and sends to pingback services. 2935 * 2936 * @since 2.1.0 2937 * @since 5.6.0 Introduced `do_all_pings` action hook for individual services. 2938 */ 2939 function do_all_pings() { 2940 /** 2941 * Fires immediately after the `do_pings` event to hook services individually. 2942 * 2943 * @since 5.6.0 2944 */ 2945 do_action( 'do_all_pings' ); 2946 } 2947 2948 /** 2949 * Performs all pingbacks. 2950 * 2951 * @since 5.6.0 2952 */ 2953 function do_all_pingbacks() { 2954 $pings = get_posts( 2955 array( 2956 'post_type' => get_post_types(), 2957 'suppress_filters' => false, 2958 'nopaging' => true, 2959 'meta_key' => '_pingme', 2960 'fields' => 'ids', 2961 ) 2962 ); 2963 2964 foreach ( $pings as $ping ) { 2965 delete_post_meta( $ping, '_pingme' ); 2966 pingback( null, $ping ); 2967 } 2968 } 2969 2970 /** 2971 * Performs all enclosures. 2972 * 2973 * @since 5.6.0 2974 */ 2975 function do_all_enclosures() { 2976 $enclosures = get_posts( 2977 array( 2978 'post_type' => get_post_types(), 2979 'suppress_filters' => false, 2980 'nopaging' => true, 2981 'meta_key' => '_encloseme', 2982 'fields' => 'ids', 2983 ) 2984 ); 2985 2986 foreach ( $enclosures as $enclosure ) { 2987 delete_post_meta( $enclosure, '_encloseme' ); 2988 do_enclose( null, $enclosure ); 2989 } 2990 } 2991 2992 /** 2993 * Performs all trackbacks. 2994 * 2995 * @since 5.6.0 2996 */ 2997 function do_all_trackbacks() { 2998 $trackbacks = get_posts( 2999 array( 3000 'post_type' => get_post_types(), 3001 'suppress_filters' => false, 3002 'nopaging' => true, 3003 'meta_key' => '_trackbackme', 3004 'fields' => 'ids', 3005 ) 3006 ); 3007 3008 foreach ( $trackbacks as $trackback ) { 3009 delete_post_meta( $trackback, '_trackbackme' ); 3010 do_trackbacks( $trackback ); 3011 } 3012 } 3013 3014 /** 3015 * Performs trackbacks. 3016 * 3017 * @since 1.5.0 3018 * @since 4.7.0 `$post` can be a WP_Post object. 3019 * 3020 * @global wpdb $wpdb WordPress database abstraction object. 3021 * 3022 * @param int|WP_Post $post Post ID or object to do trackbacks on. 3023 * @return void|false Returns false on failure. 3024 */ 3025 function do_trackbacks( $post ) { 3026 global $wpdb; 3027 3028 $post = get_post( $post ); 3029 3030 if ( ! $post ) { 3031 return false; 3032 } 3033 3034 $to_ping = get_to_ping( $post ); 3035 $pinged = get_pung( $post ); 3036 3037 if ( empty( $to_ping ) ) { 3038 $wpdb->update( $wpdb->posts, array( 'to_ping' => '' ), array( 'ID' => $post->ID ) ); 3039 return; 3040 } 3041 3042 if ( empty( $post->post_excerpt ) ) { 3043 /** This filter is documented in wp-includes/post-template.php */ 3044 $excerpt = apply_filters( 'the_content', $post->post_content, $post->ID ); 3045 } else { 3046 /** This filter is documented in wp-includes/post-template.php */ 3047 $excerpt = apply_filters( 'the_excerpt', $post->post_excerpt ); 3048 } 3049 3050 $excerpt = str_replace( ']]>', ']]>', $excerpt ); 3051 $excerpt = wp_html_excerpt( $excerpt, 252, '…' ); 3052 3053 /** This filter is documented in wp-includes/post-template.php */ 3054 $post_title = apply_filters( 'the_title', $post->post_title, $post->ID ); 3055 $post_title = strip_tags( $post_title ); 3056 3057 if ( $to_ping ) { 3058 foreach ( (array) $to_ping as $tb_ping ) { 3059 $tb_ping = trim( $tb_ping ); 3060 if ( ! in_array( $tb_ping, $pinged, true ) ) { 3061 trackback( $tb_ping, $post_title, $excerpt, $post->ID ); 3062 $pinged[] = $tb_ping; 3063 } else { 3064 $wpdb->query( 3065 $wpdb->prepare( 3066 "UPDATE $wpdb->posts SET to_ping = TRIM(REPLACE(to_ping, %s, 3067 '')) WHERE ID = %d", 3068 $tb_ping, 3069 $post->ID 3070 ) 3071 ); 3072 } 3073 } 3074 } 3075 } 3076 3077 /** 3078 * Sends pings to all of the ping site services. 3079 * 3080 * @since 1.2.0 3081 * 3082 * @param int $post_id Post ID. 3083 * @return int Same post ID as provided. 3084 */ 3085 function generic_ping( $post_id = 0 ) { 3086 $services = get_option( 'ping_sites' ); 3087 3088 $services = explode( "\n", $services ); 3089 foreach ( (array) $services as $service ) { 3090 $service = trim( $service ); 3091 if ( '' !== $service ) { 3092 weblog_ping( $service ); 3093 } 3094 } 3095 3096 return $post_id; 3097 } 3098 3099 /** 3100 * Pings back the links found in a post. 3101 * 3102 * @since 0.71 3103 * @since 4.7.0 `$post` can be a WP_Post object. 3104 * @since 6.8.0 Returns an array of pingback statuses indexed by link. 3105 * 3106 * @param string $content Post content to check for links. If empty will retrieve from post. 3107 * @param int|WP_Post $post Post ID or object. 3108 * @return array<string, bool> An array of pingback statuses indexed by link. 3109 */ 3110 function pingback( $content, $post ) { 3111 require_once ABSPATH . WPINC . '/class-IXR.php'; 3112 require_once ABSPATH . WPINC . '/class-wp-http-ixr-client.php'; 3113 3114 // Original code by Mort (http://mort.mine.nu:8080). 3115 $post_links = array(); 3116 3117 $post = get_post( $post ); 3118 3119 if ( ! $post ) { 3120 return array(); 3121 } 3122 3123 $pung = get_pung( $post ); 3124 3125 if ( empty( $content ) ) { 3126 $content = $post->post_content; 3127 } 3128 3129 /* 3130 * Step 1. 3131 * Parsing the post, external links (if any) are stored in the $post_links array. 3132 */ 3133 $post_links_temp = wp_extract_urls( $content ); 3134 3135 $ping_status = array(); 3136 /* 3137 * Step 2. 3138 * Walking through the links array. 3139 * First we get rid of links pointing to sites, not to specific files. 3140 * Example: 3141 * http://dummy-weblog.org 3142 * http://dummy-weblog.org/ 3143 * http://dummy-weblog.org/post.php 3144 * We don't wanna ping first and second types, even if they have a valid <link/>. 3145 */ 3146 foreach ( (array) $post_links_temp as $link_test ) { 3147 // If we haven't pung it already and it isn't a link to itself. 3148 if ( ! in_array( $link_test, $pung, true ) && ( url_to_postid( $link_test ) !== $post->ID ) 3149 // Also, let's never ping local attachments. 3150 && ! is_local_attachment( $link_test ) 3151 ) { 3152 $test = parse_url( $link_test ); 3153 if ( $test ) { 3154 if ( isset( $test['query'] ) ) { 3155 $post_links[] = $link_test; 3156 } elseif ( isset( $test['path'] ) && ( '/' !== $test['path'] ) && ( '' !== $test['path'] ) ) { 3157 $post_links[] = $link_test; 3158 } 3159 } 3160 } 3161 } 3162 3163 $post_links = array_unique( $post_links ); 3164 3165 /** 3166 * Fires just before pinging back links found in a post. 3167 * 3168 * @since 2.0.0 3169 * 3170 * @param string[] $post_links Array of link URLs to be checked (passed by reference). 3171 * @param string[] $pung Array of link URLs already pinged (passed by reference). 3172 * @param int $post_id The post ID. 3173 */ 3174 do_action_ref_array( 'pre_ping', array( &$post_links, &$pung, $post->ID ) ); 3175 3176 foreach ( (array) $post_links as $pagelinkedto ) { 3177 $pingback_server_url = discover_pingback_server_uri( $pagelinkedto ); 3178 3179 if ( $pingback_server_url ) { 3180 // Allow an additional 60 seconds for each pingback to complete. 3181 if ( function_exists( 'set_time_limit' ) ) { 3182 set_time_limit( 60 ); 3183 } 3184 3185 // Now, the RPC call. 3186 $pagelinkedfrom = get_permalink( $post ); 3187 3188 // Using a timeout of 3 seconds should be enough to cover slow servers. 3189 $client = new WP_HTTP_IXR_Client( $pingback_server_url ); 3190 $client->timeout = 3; 3191 /** 3192 * Filters the user agent sent when pinging-back a URL. 3193 * 3194 * @since 2.9.0 3195 * 3196 * @param string $concat_useragent The user agent concatenated with ' -- WordPress/' 3197 * and the WordPress version. 3198 * @param string $useragent The useragent. 3199 * @param string $pingback_server_url The server URL being linked to. 3200 * @param string $pagelinkedto URL of page linked to. 3201 * @param string $pagelinkedfrom URL of page linked from. 3202 */ 3203 $client->useragent = apply_filters( 'pingback_useragent', $client->useragent . ' -- WordPress/' . get_bloginfo( 'version' ), $client->useragent, $pingback_server_url, $pagelinkedto, $pagelinkedfrom ); 3204 // When set to true, this outputs debug messages by itself. 3205 $client->debug = false; 3206 3207 $status = $client->query( 'pingback.ping', $pagelinkedfrom, $pagelinkedto ); 3208 3209 if ( $status // Ping registered. 3210 || ( isset( $client->error->code ) && 48 === $client->error->code ) // Already registered. 3211 ) { 3212 add_ping( $post, $pagelinkedto ); 3213 } 3214 $ping_status[ $pagelinkedto ] = $status; 3215 } 3216 } 3217 3218 return $ping_status; 3219 } 3220 3221 /** 3222 * Checks whether blog is public before returning sites. 3223 * 3224 * @since 2.1.0 3225 * 3226 * @param mixed $sites Will return if blog is public, will not return if not public. 3227 * @return mixed Empty string if blog is not public, returns $sites, if site is public. 3228 */ 3229 function privacy_ping_filter( $sites ) { 3230 if ( '0' !== get_option( 'blog_public' ) ) { 3231 return $sites; 3232 } else { 3233 return ''; 3234 } 3235 } 3236 3237 /** 3238 * Sends a Trackback. 3239 * 3240 * Updates database when sending trackback to prevent duplicates. 3241 * 3242 * @since 0.71 3243 * 3244 * @global wpdb $wpdb WordPress database abstraction object. 3245 * 3246 * @param string $trackback_url URL to send trackbacks. 3247 * @param string $title Title of post. 3248 * @param string $excerpt Excerpt of post. 3249 * @param int $post_id Post ID. 3250 * @return int|false|void Database query from update. 3251 */ 3252 function trackback( $trackback_url, $title, $excerpt, $post_id ) { 3253 global $wpdb; 3254 3255 if ( empty( $trackback_url ) ) { 3256 return; 3257 } 3258 3259 $options = array(); 3260 $options['timeout'] = 10; 3261 $options['body'] = array( 3262 'title' => $title, 3263 'url' => get_permalink( $post_id ), 3264 'blog_name' => get_option( 'blogname' ), 3265 'excerpt' => $excerpt, 3266 ); 3267 3268 $response = wp_safe_remote_post( $trackback_url, $options ); 3269 3270 if ( is_wp_error( $response ) ) { 3271 return; 3272 } 3273 3274 $wpdb->query( $wpdb->prepare( "UPDATE $wpdb->posts SET pinged = CONCAT(pinged, '\n', %s) WHERE ID = %d", $trackback_url, $post_id ) ); 3275 return $wpdb->query( $wpdb->prepare( "UPDATE $wpdb->posts SET to_ping = TRIM(REPLACE(to_ping, %s, '')) WHERE ID = %d", $trackback_url, $post_id ) ); 3276 } 3277 3278 /** 3279 * Sends a pingback. 3280 * 3281 * @since 1.2.0 3282 * 3283 * @param string $server Host of blog to connect to. 3284 * @param string $path Path to send the ping. 3285 */ 3286 function weblog_ping( $server = '', $path = '' ) { 3287 require_once ABSPATH . WPINC . '/class-IXR.php'; 3288 require_once ABSPATH . WPINC . '/class-wp-http-ixr-client.php'; 3289 3290 // Using a timeout of 3 seconds should be enough to cover slow servers. 3291 $client = new WP_HTTP_IXR_Client( $server, ( ( ! strlen( trim( $path ) ) || ( '/' === $path ) ) ? false : $path ) ); 3292 $client->timeout = 3; 3293 $client->useragent .= ' -- WordPress/' . get_bloginfo( 'version' ); 3294 3295 // When set to true, this outputs debug messages by itself. 3296 $client->debug = false; 3297 $home = trailingslashit( home_url() ); 3298 if ( ! $client->query( 'weblogUpdates.extendedPing', get_option( 'blogname' ), $home, get_bloginfo( 'rss2_url' ) ) ) { // Then try a normal ping. 3299 $client->query( 'weblogUpdates.ping', get_option( 'blogname' ), $home ); 3300 } 3301 } 3302 3303 /** 3304 * Default filter attached to pingback_ping_source_uri to validate the pingback's Source URI. 3305 * 3306 * @since 3.5.1 3307 * 3308 * @see wp_http_validate_url() 3309 * 3310 * @param string $source_uri 3311 * @return string 3312 */ 3313 function pingback_ping_source_uri( $source_uri ) { 3314 return (string) wp_http_validate_url( $source_uri ); 3315 } 3316 3317 /** 3318 * Default filter attached to xmlrpc_pingback_error. 3319 * 3320 * Returns a generic pingback error code unless the error code is 48, 3321 * which reports that the pingback is already registered. 3322 * 3323 * @since 3.5.1 3324 * 3325 * @link https://www.hixie.ch/specs/pingback/pingback#TOC3 3326 * 3327 * @param IXR_Error $ixr_error 3328 * @return IXR_Error 3329 */ 3330 function xmlrpc_pingback_error( $ixr_error ) { 3331 if ( 48 === $ixr_error->code ) { 3332 return $ixr_error; 3333 } 3334 return new IXR_Error( 0, '' ); 3335 } 3336 3337 // 3338 // Cache. 3339 // 3340 3341 /** 3342 * Removes a comment from the object cache. 3343 * 3344 * @since 2.3.0 3345 * 3346 * @param int|array $ids Comment ID or an array of comment IDs to remove from cache. 3347 */ 3348 function clean_comment_cache( $ids ) { 3349 $comment_ids = (array) $ids; 3350 wp_cache_delete_multiple( $comment_ids, 'comment' ); 3351 foreach ( $comment_ids as $id ) { 3352 /** 3353 * Fires immediately after a comment has been removed from the object cache. 3354 * 3355 * @since 4.5.0 3356 * 3357 * @param int $id Comment ID. 3358 */ 3359 do_action( 'clean_comment_cache', $id ); 3360 } 3361 3362 wp_cache_set_comments_last_changed(); 3363 } 3364 3365 /** 3366 * Updates the comment cache of given comments. 3367 * 3368 * Will add the comments in $comments to the cache. If comment ID already exists 3369 * in the comment cache then it will not be updated. The comment is added to the 3370 * cache using the comment group with the key using the ID of the comments. 3371 * 3372 * @since 2.3.0 3373 * @since 4.4.0 Introduced the `$update_meta_cache` parameter. 3374 * 3375 * @param WP_Comment[] $comments Array of comment objects 3376 * @param bool $update_meta_cache Whether to update commentmeta cache. Default true. 3377 */ 3378 function update_comment_cache( $comments, $update_meta_cache = true ) { 3379 $data = array(); 3380 foreach ( (array) $comments as $comment ) { 3381 $data[ $comment->comment_ID ] = $comment; 3382 } 3383 wp_cache_add_multiple( $data, 'comment' ); 3384 3385 if ( $update_meta_cache ) { 3386 // Avoid `wp_list_pluck()` in case `$comments` is passed by reference. 3387 $comment_ids = array(); 3388 foreach ( $comments as $comment ) { 3389 $comment_ids[] = $comment->comment_ID; 3390 } 3391 update_meta_cache( 'comment', $comment_ids ); 3392 } 3393 } 3394 3395 /** 3396 * Adds any comments from the given IDs to the cache that do not already exist in cache. 3397 * 3398 * @since 4.4.0 3399 * @since 6.1.0 This function is no longer marked as "private". 3400 * @since 6.3.0 Use wp_lazyload_comment_meta() for lazy-loading of comment meta. 3401 * 3402 * @see update_comment_cache() 3403 * @global wpdb $wpdb WordPress database abstraction object. 3404 * 3405 * @param int[] $comment_ids Array of comment IDs. 3406 * @param bool $update_meta_cache Optional. Whether to update the meta cache. Default true. 3407 */ 3408 function _prime_comment_caches( $comment_ids, $update_meta_cache = true ) { 3409 global $wpdb; 3410 3411 $non_cached_ids = _get_non_cached_ids( $comment_ids, 'comment' ); 3412 if ( ! empty( $non_cached_ids ) ) { 3413 $fresh_comments = $wpdb->get_results( sprintf( "SELECT $wpdb->comments.* FROM $wpdb->comments WHERE comment_ID IN (%s)", implode( ',', array_map( 'intval', $non_cached_ids ) ) ) ); 3414 3415 update_comment_cache( $fresh_comments, false ); 3416 } 3417 3418 if ( $update_meta_cache ) { 3419 wp_lazyload_comment_meta( $comment_ids ); 3420 } 3421 } 3422 3423 // 3424 // Internal. 3425 // 3426 3427 /** 3428 * Closes comments on old posts on the fly, without any extra DB queries. Hooked to the_posts. 3429 * 3430 * @since 2.7.0 3431 * @access private 3432 * 3433 * @param WP_Post $posts Post data object. 3434 * @param WP_Query $query Query object. 3435 * @return array 3436 */ 3437 function _close_comments_for_old_posts( $posts, $query ) { 3438 if ( empty( $posts ) || ! $query->is_singular() || ! get_option( 'close_comments_for_old_posts' ) ) { 3439 return $posts; 3440 } 3441 3442 /** 3443 * Filters the list of post types to automatically close comments for. 3444 * 3445 * @since 3.2.0 3446 * 3447 * @param string[] $post_types An array of post type names. 3448 */ 3449 $post_types = apply_filters( 'close_comments_for_post_types', array( 'post' ) ); 3450 if ( ! in_array( $posts[0]->post_type, $post_types, true ) ) { 3451 return $posts; 3452 } 3453 3454 $days_old = (int) get_option( 'close_comments_days_old' ); 3455 if ( ! $days_old ) { 3456 return $posts; 3457 } 3458 3459 if ( time() - strtotime( $posts[0]->post_date_gmt ) > ( $days_old * DAY_IN_SECONDS ) ) { 3460 $posts[0]->comment_status = 'closed'; 3461 $posts[0]->ping_status = 'closed'; 3462 } 3463 3464 return $posts; 3465 } 3466 3467 /** 3468 * Closes comments on an old post. Hooked to comments_open and pings_open. 3469 * 3470 * @since 2.7.0 3471 * @access private 3472 * 3473 * @param bool $open Comments open or closed. 3474 * @param int $post_id Post ID. 3475 * @return bool $open 3476 */ 3477 function _close_comments_for_old_post( $open, $post_id ) { 3478 if ( ! $open ) { 3479 return $open; 3480 } 3481 3482 if ( ! get_option( 'close_comments_for_old_posts' ) ) { 3483 return $open; 3484 } 3485 3486 $days_old = (int) get_option( 'close_comments_days_old' ); 3487 if ( ! $days_old ) { 3488 return $open; 3489 } 3490 3491 $post = get_post( $post_id ); 3492 3493 /** This filter is documented in wp-includes/comment.php */ 3494 $post_types = apply_filters( 'close_comments_for_post_types', array( 'post' ) ); 3495 if ( ! in_array( $post->post_type, $post_types, true ) ) { 3496 return $open; 3497 } 3498 3499 // Undated drafts should not show up as comments closed. 3500 if ( '0000-00-00 00:00:00' === $post->post_date_gmt ) { 3501 return $open; 3502 } 3503 3504 if ( time() - strtotime( $post->post_date_gmt ) > ( $days_old * DAY_IN_SECONDS ) ) { 3505 return false; 3506 } 3507 3508 return $open; 3509 } 3510 3511 /** 3512 * Handles the submission of a comment, usually posted to wp-comments-post.php via a comment form. 3513 * 3514 * This function expects unslashed data, as opposed to functions such as `wp_new_comment()` which 3515 * expect slashed data. 3516 * 3517 * @since 4.4.0 3518 * 3519 * @param array $comment_data { 3520 * Comment data. 3521 * 3522 * @type string|int $comment_post_ID The ID of the post that relates to the comment. 3523 * @type string $author The name of the comment author. 3524 * @type string $email The comment author email address. 3525 * @type string $url The comment author URL. 3526 * @type string $comment The content of the comment. 3527 * @type string|int $comment_parent The ID of this comment's parent, if any. Default 0. 3528 * @type string $_wp_unfiltered_html_comment The nonce value for allowing unfiltered HTML. 3529 * } 3530 * @return WP_Comment|WP_Error A WP_Comment object on success, a WP_Error object on failure. 3531 */ 3532 function wp_handle_comment_submission( $comment_data ) { 3533 $comment_post_id = 0; 3534 $comment_author = ''; 3535 $comment_author_email = ''; 3536 $comment_author_url = ''; 3537 $comment_content = ''; 3538 $comment_parent = 0; 3539 $user_id = 0; 3540 3541 if ( isset( $comment_data['comment_post_ID'] ) ) { 3542 $comment_post_id = (int) $comment_data['comment_post_ID']; 3543 } 3544 if ( isset( $comment_data['author'] ) && is_string( $comment_data['author'] ) ) { 3545 $comment_author = trim( strip_tags( $comment_data['author'] ) ); 3546 } 3547 if ( isset( $comment_data['email'] ) && is_string( $comment_data['email'] ) ) { 3548 $comment_author_email = trim( $comment_data['email'] ); 3549 } 3550 if ( isset( $comment_data['url'] ) && is_string( $comment_data['url'] ) ) { 3551 $comment_author_url = trim( $comment_data['url'] ); 3552 } 3553 if ( isset( $comment_data['comment'] ) && is_string( $comment_data['comment'] ) ) { 3554 $comment_content = trim( $comment_data['comment'] ); 3555 } 3556 if ( isset( $comment_data['comment_parent'] ) ) { 3557 $comment_parent = absint( $comment_data['comment_parent'] ); 3558 $comment_parent_object = get_comment( $comment_parent ); 3559 3560 if ( 3561 0 !== $comment_parent && 3562 ( 3563 ! $comment_parent_object instanceof WP_Comment || 3564 0 === (int) $comment_parent_object->comment_approved 3565 ) 3566 ) { 3567 /** 3568 * Fires when a comment reply is attempted to an unapproved comment. 3569 * 3570 * @since 6.2.0 3571 * 3572 * @param int $comment_post_id Post ID. 3573 * @param int $comment_parent Parent comment ID. 3574 */ 3575 do_action( 'comment_reply_to_unapproved_comment', $comment_post_id, $comment_parent ); 3576 3577 return new WP_Error( 'comment_reply_to_unapproved_comment', __( 'Sorry, replies to unapproved comments are not allowed.' ), 403 ); 3578 } 3579 } 3580 3581 $post = get_post( $comment_post_id ); 3582 3583 if ( empty( $post->comment_status ) ) { 3584 3585 /** 3586 * Fires when a comment is attempted on a post that does not exist. 3587 * 3588 * @since 1.5.0 3589 * 3590 * @param int $comment_post_id Post ID. 3591 */ 3592 do_action( 'comment_id_not_found', $comment_post_id ); 3593 3594 return new WP_Error( 'comment_id_not_found' ); 3595 3596 } 3597 3598 // get_post_status() will get the parent status for attachments. 3599 $status = get_post_status( $post ); 3600 3601 if ( ( 'private' === $status ) && ! current_user_can( 'read_post', $comment_post_id ) ) { 3602 return new WP_Error( 'comment_id_not_found' ); 3603 } 3604 3605 $status_obj = get_post_status_object( $status ); 3606 3607 if ( ! comments_open( $comment_post_id ) ) { 3608 3609 /** 3610 * Fires when a comment is attempted on a post that has comments closed. 3611 * 3612 * @since 1.5.0 3613 * 3614 * @param int $comment_post_id Post ID. 3615 */ 3616 do_action( 'comment_closed', $comment_post_id ); 3617 3618 return new WP_Error( 'comment_closed', __( 'Sorry, comments are closed for this item.' ), 403 ); 3619 3620 } elseif ( 'trash' === $status ) { 3621 3622 /** 3623 * Fires when a comment is attempted on a trashed post. 3624 * 3625 * @since 2.9.0 3626 * 3627 * @param int $comment_post_id Post ID. 3628 */ 3629 do_action( 'comment_on_trash', $comment_post_id ); 3630 3631 return new WP_Error( 'comment_on_trash' ); 3632 3633 } elseif ( ! $status_obj->public && ! $status_obj->private ) { 3634 3635 /** 3636 * Fires when a comment is attempted on a post in draft mode. 3637 * 3638 * @since 1.5.1 3639 * 3640 * @param int $comment_post_id Post ID. 3641 */ 3642 do_action( 'comment_on_draft', $comment_post_id ); 3643 3644 if ( current_user_can( 'read_post', $comment_post_id ) ) { 3645 return new WP_Error( 'comment_on_draft', __( 'Sorry, comments are not allowed for this item.' ), 403 ); 3646 } else { 3647 return new WP_Error( 'comment_on_draft' ); 3648 } 3649 } elseif ( post_password_required( $comment_post_id ) ) { 3650 3651 /** 3652 * Fires when a comment is attempted on a password-protected post. 3653 * 3654 * @since 2.9.0 3655 * 3656 * @param int $comment_post_id Post ID. 3657 */ 3658 do_action( 'comment_on_password_protected', $comment_post_id ); 3659 3660 return new WP_Error( 'comment_on_password_protected' ); 3661 3662 } else { 3663 /** 3664 * Fires before a comment is posted. 3665 * 3666 * @since 2.8.0 3667 * 3668 * @param int $comment_post_id Post ID. 3669 */ 3670 do_action( 'pre_comment_on_post', $comment_post_id ); 3671 } 3672 3673 // If the user is logged in. 3674 $user = wp_get_current_user(); 3675 if ( $user->exists() ) { 3676 if ( empty( $user->display_name ) ) { 3677 $user->display_name = $user->user_login; 3678 } 3679 3680 $comment_author = $user->display_name; 3681 $comment_author_email = $user->user_email; 3682 $comment_author_url = $user->user_url; 3683 $user_id = $user->ID; 3684 3685 if ( current_user_can( 'unfiltered_html' ) ) { 3686 if ( ! isset( $comment_data['_wp_unfiltered_html_comment'] ) 3687 || ! wp_verify_nonce( $comment_data['_wp_unfiltered_html_comment'], 'unfiltered-html-comment_' . $comment_post_id ) 3688 ) { 3689 kses_remove_filters(); // Start with a clean slate. 3690 kses_init_filters(); // Set up the filters. 3691 remove_filter( 'pre_comment_content', 'wp_filter_post_kses' ); 3692 add_filter( 'pre_comment_content', 'wp_filter_kses' ); 3693 } 3694 } 3695 } else { 3696 if ( get_option( 'comment_registration' ) ) { 3697 return new WP_Error( 'not_logged_in', __( 'Sorry, you must be logged in to comment.' ), 403 ); 3698 } 3699 } 3700 3701 $comment_type = 'comment'; 3702 3703 if ( get_option( 'require_name_email' ) && ! $user->exists() ) { 3704 if ( '' === $comment_author_email || '' === $comment_author ) { 3705 return new WP_Error( 'require_name_email', __( '<strong>Error:</strong> Please fill the required fields.' ), 200 ); 3706 } elseif ( ! is_email( $comment_author_email ) ) { 3707 return new WP_Error( 'require_valid_email', __( '<strong>Error:</strong> Please enter a valid email address.' ), 200 ); 3708 } 3709 } 3710 3711 $commentdata = array( 3712 'comment_post_ID' => $comment_post_id, 3713 ); 3714 3715 $commentdata += compact( 3716 'comment_author', 3717 'comment_author_email', 3718 'comment_author_url', 3719 'comment_content', 3720 'comment_type', 3721 'comment_parent', 3722 'user_id' 3723 ); 3724 3725 /** 3726 * Filters whether an empty comment should be allowed. 3727 * 3728 * @since 5.1.0 3729 * 3730 * @param bool $allow_empty_comment Whether to allow empty comments. Default false. 3731 * @param array $commentdata Array of comment data to be sent to wp_insert_comment(). 3732 */ 3733 $allow_empty_comment = apply_filters( 'allow_empty_comment', false, $commentdata ); 3734 if ( '' === $comment_content && ! $allow_empty_comment ) { 3735 return new WP_Error( 'require_valid_comment', __( '<strong>Error:</strong> Please type your comment text.' ), 200 ); 3736 } 3737 3738 $check_max_lengths = wp_check_comment_data_max_lengths( $commentdata ); 3739 if ( is_wp_error( $check_max_lengths ) ) { 3740 return $check_max_lengths; 3741 } 3742 3743 $comment_id = wp_new_comment( wp_slash( $commentdata ), true ); 3744 if ( is_wp_error( $comment_id ) ) { 3745 return $comment_id; 3746 } 3747 3748 if ( ! $comment_id ) { 3749 return new WP_Error( 'comment_save_error', __( '<strong>Error:</strong> The comment could not be saved. Please try again later.' ), 500 ); 3750 } 3751 3752 return get_comment( $comment_id ); 3753 } 3754 3755 /** 3756 * Registers the personal data exporter for comments. 3757 * 3758 * @since 4.9.6 3759 * 3760 * @param array[] $exporters An array of personal data exporters. 3761 * @return array[] An array of personal data exporters. 3762 */ 3763 function wp_register_comment_personal_data_exporter( $exporters ) { 3764 $exporters['wordpress-comments'] = array( 3765 'exporter_friendly_name' => __( 'WordPress Comments' ), 3766 'callback' => 'wp_comments_personal_data_exporter', 3767 ); 3768 3769 return $exporters; 3770 } 3771 3772 /** 3773 * Finds and exports personal data associated with an email address from the comments table. 3774 * 3775 * @since 4.9.6 3776 * 3777 * @param string $email_address The comment author email address. 3778 * @param int $page Comment page number. 3779 * @return array { 3780 * An array of personal data. 3781 * 3782 * @type array[] $data An array of personal data arrays. 3783 * @type bool $done Whether the exporter is finished. 3784 * } 3785 */ 3786 function wp_comments_personal_data_exporter( $email_address, $page = 1 ) { 3787 // Limit us to 500 comments at a time to avoid timing out. 3788 $number = 500; 3789 $page = (int) $page; 3790 3791 $data_to_export = array(); 3792 3793 $comments = get_comments( 3794 array( 3795 'author_email' => $email_address, 3796 'number' => $number, 3797 'paged' => $page, 3798 'orderby' => 'comment_ID', 3799 'order' => 'ASC', 3800 'update_comment_meta_cache' => false, 3801 ) 3802 ); 3803 3804 $comment_prop_to_export = array( 3805 'comment_author' => __( 'Comment Author' ), 3806 'comment_author_email' => __( 'Comment Author Email' ), 3807 'comment_author_url' => __( 'Comment Author URL' ), 3808 'comment_author_IP' => __( 'Comment Author IP' ), 3809 'comment_agent' => __( 'Comment Author User Agent' ), 3810 'comment_date' => __( 'Comment Date' ), 3811 'comment_content' => __( 'Comment Content' ), 3812 'comment_link' => __( 'Comment URL' ), 3813 ); 3814 3815 foreach ( (array) $comments as $comment ) { 3816 $comment_data_to_export = array(); 3817 3818 foreach ( $comment_prop_to_export as $key => $name ) { 3819 $value = ''; 3820 3821 switch ( $key ) { 3822 case 'comment_author': 3823 case 'comment_author_email': 3824 case 'comment_author_url': 3825 case 'comment_author_IP': 3826 case 'comment_agent': 3827 case 'comment_date': 3828 $value = $comment->{$key}; 3829 break; 3830 3831 case 'comment_content': 3832 $value = get_comment_text( $comment->comment_ID ); 3833 break; 3834 3835 case 'comment_link': 3836 $value = get_comment_link( $comment->comment_ID ); 3837 $value = sprintf( 3838 '<a href="%s" target="_blank">%s</a>', 3839 esc_url( $value ), 3840 esc_html( $value ) 3841 ); 3842 break; 3843 } 3844 3845 if ( ! empty( $value ) ) { 3846 $comment_data_to_export[] = array( 3847 'name' => $name, 3848 'value' => $value, 3849 ); 3850 } 3851 } 3852 3853 $data_to_export[] = array( 3854 'group_id' => 'comments', 3855 'group_label' => __( 'Comments' ), 3856 'group_description' => __( 'User’s comment data.' ), 3857 'item_id' => "comment-{$comment->comment_ID}", 3858 'data' => $comment_data_to_export, 3859 ); 3860 } 3861 3862 $done = count( $comments ) < $number; 3863 3864 return array( 3865 'data' => $data_to_export, 3866 'done' => $done, 3867 ); 3868 } 3869 3870 /** 3871 * Registers the personal data eraser for comments. 3872 * 3873 * @since 4.9.6 3874 * 3875 * @param array $erasers An array of personal data erasers. 3876 * @return array An array of personal data erasers. 3877 */ 3878 function wp_register_comment_personal_data_eraser( $erasers ) { 3879 $erasers['wordpress-comments'] = array( 3880 'eraser_friendly_name' => __( 'WordPress Comments' ), 3881 'callback' => 'wp_comments_personal_data_eraser', 3882 ); 3883 3884 return $erasers; 3885 } 3886 3887 /** 3888 * Erases personal data associated with an email address from the comments table. 3889 * 3890 * @since 4.9.6 3891 * 3892 * @global wpdb $wpdb WordPress database abstraction object. 3893 * 3894 * @param string $email_address The comment author email address. 3895 * @param int $page Comment page number. 3896 * @return array { 3897 * Data removal results. 3898 * 3899 * @type bool $items_removed Whether items were actually removed. 3900 * @type bool $items_retained Whether items were retained. 3901 * @type string[] $messages An array of messages to add to the personal data export file. 3902 * @type bool $done Whether the eraser is finished. 3903 * } 3904 */ 3905 function wp_comments_personal_data_eraser( $email_address, $page = 1 ) { 3906 global $wpdb; 3907 3908 if ( empty( $email_address ) ) { 3909 return array( 3910 'items_removed' => false, 3911 'items_retained' => false, 3912 'messages' => array(), 3913 'done' => true, 3914 ); 3915 } 3916 3917 // Limit us to 500 comments at a time to avoid timing out. 3918 $number = 500; 3919 $page = (int) $page; 3920 $items_removed = false; 3921 $items_retained = false; 3922 3923 $comments = get_comments( 3924 array( 3925 'author_email' => $email_address, 3926 'number' => $number, 3927 'paged' => $page, 3928 'orderby' => 'comment_ID', 3929 'order' => 'ASC', 3930 'include_unapproved' => true, 3931 ) 3932 ); 3933 3934 /* translators: Name of a comment's author after being anonymized. */ 3935 $anon_author = __( 'Anonymous' ); 3936 $messages = array(); 3937 3938 foreach ( (array) $comments as $comment ) { 3939 $anonymized_comment = array(); 3940 $anonymized_comment['comment_agent'] = ''; 3941 $anonymized_comment['comment_author'] = $anon_author; 3942 $anonymized_comment['comment_author_email'] = ''; 3943 $anonymized_comment['comment_author_IP'] = wp_privacy_anonymize_data( 'ip', $comment->comment_author_IP ); 3944 $anonymized_comment['comment_author_url'] = ''; 3945 $anonymized_comment['user_id'] = 0; 3946 3947 $comment_id = (int) $comment->comment_ID; 3948 3949 /** 3950 * Filters whether to anonymize the comment. 3951 * 3952 * @since 4.9.6 3953 * 3954 * @param bool|string $anon_message Whether to apply the comment anonymization (bool) or a custom 3955 * message (string). Default true. 3956 * @param WP_Comment $comment WP_Comment object. 3957 * @param array $anonymized_comment Anonymized comment data. 3958 */ 3959 $anon_message = apply_filters( 'wp_anonymize_comment', true, $comment, $anonymized_comment ); 3960 3961 if ( true !== $anon_message ) { 3962 if ( $anon_message && is_string( $anon_message ) ) { 3963 $messages[] = esc_html( $anon_message ); 3964 } else { 3965 /* translators: %d: Comment ID. */ 3966 $messages[] = sprintf( __( 'Comment %d contains personal data but could not be anonymized.' ), $comment_id ); 3967 } 3968 3969 $items_retained = true; 3970 3971 continue; 3972 } 3973 3974 $args = array( 3975 'comment_ID' => $comment_id, 3976 ); 3977 3978 $updated = $wpdb->update( $wpdb->comments, $anonymized_comment, $args ); 3979 3980 if ( $updated ) { 3981 $items_removed = true; 3982 clean_comment_cache( $comment_id ); 3983 } else { 3984 $items_retained = true; 3985 } 3986 } 3987 3988 $done = count( $comments ) < $number; 3989 3990 return array( 3991 'items_removed' => $items_removed, 3992 'items_retained' => $items_retained, 3993 'messages' => $messages, 3994 'done' => $done, 3995 ); 3996 } 3997 3998 /** 3999 * Sets the last changed time for the 'comment' cache group. 4000 * 4001 * @since 5.0.0 4002 */ 4003 function wp_cache_set_comments_last_changed() { 4004 wp_cache_set_last_changed( 'comment' ); 4005 } 4006 4007 /** 4008 * Updates the comment type for a batch of comments. 4009 * 4010 * @since 5.5.0 4011 * 4012 * @global wpdb $wpdb WordPress database abstraction object. 4013 */ 4014 function _wp_batch_update_comment_type() { 4015 global $wpdb; 4016 4017 $lock_name = 'update_comment_type.lock'; 4018 4019 // Try to lock. 4020 $lock_result = $wpdb->query( $wpdb->prepare( "INSERT IGNORE INTO `$wpdb->options` ( `option_name`, `option_value`, `autoload` ) VALUES (%s, %s, 'no') /* LOCK */", $lock_name, time() ) ); 4021 4022 if ( ! $lock_result ) { 4023 $lock_result = get_option( $lock_name ); 4024 4025 // Bail if we were unable to create a lock, or if the existing lock is still valid. 4026 if ( ! $lock_result || ( $lock_result > ( time() - HOUR_IN_SECONDS ) ) ) { 4027 wp_schedule_single_event( time() + ( 5 * MINUTE_IN_SECONDS ), 'wp_update_comment_type_batch' ); 4028 return; 4029 } 4030 } 4031 4032 // Update the lock, as by this point we've definitely got a lock, just need to fire the actions. 4033 update_option( $lock_name, time() ); 4034 4035 // Check if there's still an empty comment type. 4036 $empty_comment_type = $wpdb->get_var( 4037 "SELECT comment_ID FROM $wpdb->comments 4038 WHERE comment_type = '' 4039 LIMIT 1" 4040 ); 4041 4042 // No empty comment type, we're done here. 4043 if ( ! $empty_comment_type ) { 4044 update_option( 'finished_updating_comment_type', true ); 4045 delete_option( $lock_name ); 4046 return; 4047 } 4048 4049 // Empty comment type found? We'll need to run this script again. 4050 wp_schedule_single_event( time() + ( 2 * MINUTE_IN_SECONDS ), 'wp_update_comment_type_batch' ); 4051 4052 /** 4053 * Filters the comment batch size for updating the comment type. 4054 * 4055 * @since 5.5.0 4056 * 4057 * @param int $comment_batch_size The comment batch size. Default 100. 4058 */ 4059 $comment_batch_size = (int) apply_filters( 'wp_update_comment_type_batch_size', 100 ); 4060 4061 // Get the IDs of the comments to update. 4062 $comment_ids = $wpdb->get_col( 4063 $wpdb->prepare( 4064 "SELECT comment_ID 4065 FROM {$wpdb->comments} 4066 WHERE comment_type = '' 4067 ORDER BY comment_ID DESC 4068 LIMIT %d", 4069 $comment_batch_size 4070 ) 4071 ); 4072 4073 if ( $comment_ids ) { 4074 $comment_id_list = implode( ',', $comment_ids ); 4075 4076 // Update the `comment_type` field value to be `comment` for the next batch of comments. 4077 $wpdb->query( 4078 "UPDATE {$wpdb->comments} 4079 SET comment_type = 'comment' 4080 WHERE comment_type = '' 4081 AND comment_ID IN ({$comment_id_list})" // phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared 4082 ); 4083 4084 // Make sure to clean the comment cache. 4085 clean_comment_cache( $comment_ids ); 4086 } 4087 4088 delete_option( $lock_name ); 4089 } 4090 4091 /** 4092 * In order to avoid the _wp_batch_update_comment_type() job being accidentally removed, 4093 * check that it's still scheduled while we haven't finished updating comment types. 4094 * 4095 * @ignore 4096 * @since 5.5.0 4097 */ 4098 function _wp_check_for_scheduled_update_comment_type() { 4099 if ( ! get_option( 'finished_updating_comment_type' ) && ! wp_next_scheduled( 'wp_update_comment_type_batch' ) ) { 4100 wp_schedule_single_event( time() + MINUTE_IN_SECONDS, 'wp_update_comment_type_batch' ); 4101 } 4102 }
title
Description
Body
title
Description
Body
title
Description
Body
title
Body
| Generated : Thu Apr 10 08:20:01 2025 | Cross-referenced by PHPXref |