WordPress.org

Make WordPress Core

Ticket #27506: 27506.2.diff

File 27506.2.diff, 42.7 KB (added by DrewAPicture, 7 years ago)

2nd pass

  • src/wp-includes/class-wp-xmlrpc-server.php

     
    127127                );
    128128
    129129                $this->initialise_blog_option_info();
    130                 $this->methods = apply_filters('xmlrpc_methods', $this->methods);
     130
     131                /**
     132                 * Filter the methods exposed by the XML-RPC server.
     133                 *
     134                 * This filter can be used to add new methods, and remove built-in methods.
     135                 *
     136                 * @since 1.5.0
     137                 *
     138                 * @param array $methods An array of XML-RPC methods.
     139                 */
     140                $this->methods = apply_filters( 'xmlrpc_methods', $this->methods );
    131141        }
    132142
    133143        function serve_request() {
     
    171181         */
    172182        function login( $username, $password ) {
    173183                // Respect any old filters against get_option() for 'enable_xmlrpc'.
    174                 $enabled = apply_filters( 'pre_option_enable_xmlrpc', false ); // Deprecated
     184
     185                /**
     186                 * Filter whether XML-RPC is enabled.
     187                 *
     188                 * @since 3.5.0
     189                 * @deprecated 3.5.0 Use 'xmlrpc_enabled' instead.
     190                 *
     191                 * @param bool $enable Whether to enable XML-RPC. Default false.
     192                 */
     193                $enabled = apply_filters( 'pre_option_enable_xmlrpc', false );
    175194                if ( false === $enabled )
    176                         $enabled = apply_filters( 'option_enable_xmlrpc', true ); // Deprecated
    177195
    178                 // Proper filter for turning off XML-RPC. It is on by default.
     196                        /**
     197                         * Filter whether XML-RPC is enabled.
     198                         *
     199                         * @since 3.5.0
     200                         * @deprecated 3.5.0 Use xmlrpc_enabled instead.
     201                         *
     202                         * @param bool $enable Whether to enable XML-RPC. Default true.
     203                         */
     204                        $enabled = apply_filters( 'option_enable_xmlrpc', true );
     205
     206                /**
     207                 * Filter whether XML-RPC is enabled.
     208                 *
     209                 * This is the proper filter for turning off XML-RPC.
     210                 *
     211                 * @since 3.5.0
     212                 *
     213                 * @param bool $enabled Whether XML-RPC is enabled. Default true.
     214                 */
    179215                $enabled = apply_filters( 'xmlrpc_enabled', $enabled );
    180216
    181217                if ( ! $enabled ) {
     
    187223
    188224                if (is_wp_error($user)) {
    189225                        $this->error = new IXR_Error( 403, __( 'Incorrect username or password.' ) );
     226
     227                        /**
     228                         * Filter the XML-RPC user login error message.
     229                         *
     230                         * @since 3.5.0
     231                         *
     232                         * @param string  $error The error message.
     233                         * @param WP_User $user  WP_User object.
     234                         */
    190235                        $this->error = apply_filters( 'xmlrpc_login_error', $this->error, $user );
    191236                        return false;
    192237                }
     
    441486                        )
    442487                );
    443488
     489                /**
     490                 * Filter the XML-RPC blog options property.
     491                 *
     492                 * @since 2.6.0
     493                 *
     494                 * @param array $blog_options An array of blog options.
     495                 */
    444496                $this->blog_options = apply_filters( 'xmlrpc_blog_options', $this->blog_options );
    445497        }
    446498
     
    474526                if ( !$user = $this->login($username, $password) )
    475527                        return $this->error;
    476528
     529                /**
     530                 * Fires after the XML-RPC user has been authenticated but before the rest of
     531                 * the method logic begins.
     532                 *
     533                 * All built-in XML-RPC methods use the action xmlrpc_call, with a parameter
     534                 * equal to the method's name, e.g., wp.getUsersBlogs, wp.newPost, etc.
     535                 *
     536                 * @since 2.5.0
     537                 *
     538                 * @param method $name The method name.
     539                 */
    477540                do_action( 'xmlrpc_call', 'wp.getUsersBlogs' );
    478541
    479542                $blogs = (array) get_blogs_of_user( $user->ID );
     
    553616                if ( in_array( 'object_type', $fields ) )
    554617                        $_taxonomy['object_type'] = array_unique( (array) $taxonomy->object_type );
    555618
     619                /**
     620                 * Filter XML-RPC-prepared data for the given taxonomy.
     621                 *
     622                 * @since 3.4.0
     623                 *
     624                 * @param array  $_taxonomy Array of taxonomy data.
     625                 * @param object $taxonomy  Taxonomy object.
     626                 * @param array  $fields    The subset of taxonomy fields to return.
     627                 */
    556628                return apply_filters( 'xmlrpc_prepare_taxonomy', $_taxonomy, $taxonomy, $fields );
    557629        }
    558630
     
    578650                // Count we are happy to return as an integer because people really shouldn't use terms that much.
    579651                $_term['count'] = intval( $_term['count'] );
    580652
     653                /**
     654                 * Filter XML-RPC-prepared data for the given term.
     655                 *
     656                 * @since 3.4.0
     657                 *
     658                 * @param array        $_term Array of term data.
     659                 * @param array|object $term  Term object or array.
     660                 */
    581661                return apply_filters( 'xmlrpc_prepare_term', $_term, $term );
    582662        }
    583663
     
    699779                        }
    700780                }
    701781
     782                /**
     783                 * Filter XML-RPC-prepared date for the given post.
     784                 *
     785                 * @since 3.4.0
     786                 *
     787                 * @param array $_post  Array of modified post data.
     788                 * @param array $post   Array of post data.
     789                 * @param array $fields Array of post fields.
     790                 */
    702791                return apply_filters( 'xmlrpc_prepare_post', $_post, $post, $fields );
    703792        }
    704793
     
    741830                if ( in_array( 'taxonomies', $fields ) )
    742831                        $_post_type['taxonomies'] = get_object_taxonomies( $post_type->name, 'names' );
    743832
     833                /**
     834                 * Filter XML-RPC-prepared date for the given post type.
     835                 *
     836                 * @since 3.4.0
     837                 *
     838                 * @param array  $_post_type Array of post type data.
     839                 * @param object $post_type  Post type object.
     840                 */
    744841                return apply_filters( 'xmlrpc_prepare_post_type', $_post_type, $post_type );
    745842        }
    746843
     
    771868                else
    772869                        $_media_item['thumbnail'] = $_media_item['link'];
    773870
     871                /**
     872                 * Filter XML-RPC-prepared data for the given media item.
     873                 *
     874                 * @since 3.4.0
     875                 *
     876                 * @param array  $_media_item    Array of media item data.
     877                 * @param object $media_item     Media item object.
     878                 * @param string $thumbnail_size Image size.
     879                 */
    774880                return apply_filters( 'xmlrpc_prepare_media_item', $_media_item, $media_item, $thumbnail_size );
    775881        }
    776882
     
    842948                        'wp_page_template'       => $page_template
    843949                );
    844950
     951                /**
     952                 * Filter XML-RPC-prepared data for the given page.
     953                 *
     954                 * @since 3.4.0
     955                 *
     956                 * @param array   $_page Array of page data.
     957                 * @param WP_Post $page  Page object.
     958                 */
    845959                return apply_filters( 'xmlrpc_prepare_page', $_page, $page );
    846960        }
    847961
     
    884998                        'type'             => $comment->comment_type,
    885999                );
    8861000
     1001                /**
     1002                 * Filter XML-RPC-prepared data for the given comment.
     1003                 *
     1004                 * @since 3.4.0
     1005                 *
     1006                 * @param array  $_comment Array of prepared comment data.
     1007                 * @param object $comment  Comment object.
     1008                 */
    8871009                return apply_filters( 'xmlrpc_prepare_comment', $_comment, $comment );
    8881010        }
    8891011
     
    9241046                        $_user = array_merge( $_user, $requested_fields );
    9251047                }
    9261048
     1049                /**
     1050                 * Filter XML-RPC-prepared data for the given user.
     1051                 *
     1052                 * @since 3.5.0
     1053                 *
     1054                 * @param array   $_user  Array of user data.
     1055                 * @param WP_User $user   User object.
     1056                 * @param array   $fields List of user fields.
     1057                 */
    9271058                return apply_filters( 'xmlrpc_prepare_user', $_user, $user, $fields );
    9281059        }
    9291060
     
    9721103                if ( ! $user = $this->login( $username, $password ) )
    9731104                        return $this->error;
    9741105
     1106                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    9751107                do_action( 'xmlrpc_call', 'wp.newPost' );
    9761108
    9771109                unset( $content_struct['ID'] );
     
    12151347
    12161348                $this->attach_uploads( $post_ID, $post_data['post_content'] );
    12171349
     1350                /**
     1351                 * Filter post data array to be inserted via XML-RPC.
     1352                 *
     1353                 * @since 3.4.0
     1354                 *
     1355                 * @param array $post_data      Parsed array of post data.
     1356                 * @param array $content_struct Post data array.
     1357                 */
    12181358                $post_data = apply_filters( 'xmlrpc_wp_insert_post_data', $post_data, $content_struct );
    12191359
    12201360                $post_ID = $update ? wp_update_post( $post_data, true ) : wp_insert_post( $post_data, true );
     
    12581398                if ( ! $user = $this->login( $username, $password ) )
    12591399                        return $this->error;
    12601400
     1401                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    12611402                do_action( 'xmlrpc_call', 'wp.editPost' );
    12621403
    12631404                $post = get_post( $post_id, ARRAY_A );
     
    13191460                if ( ! $user = $this->login( $username, $password ) )
    13201461                        return $this->error;
    13211462
     1463                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    13221464                do_action( 'xmlrpc_call', 'wp.deletePost' );
    13231465
    13241466                $post = get_post( $post_id, ARRAY_A );
     
    13941536                if ( isset( $args[4] ) )
    13951537                        $fields = $args[4];
    13961538                else
     1539
     1540                        /**
     1541                         * Filter the conceptual XML-RPC groups used to retrieve a post.
     1542                         *
     1543                         * @since 3.4.0
     1544                         *
     1545                         * @param array $fields An array of conceptual groups. Default 'post',
     1546                         *                      'terms', 'custom_fields'.
     1547                         * @param string $method The method used to retrieve the post fields.
     1548                         *                       Default 'wp.getPost'.
     1549                         */
    13971550                        $fields = apply_filters( 'xmlrpc_default_post_fields', array( 'post', 'terms', 'custom_fields' ), 'wp.getPost' );
    13981551
    13991552                if ( ! $user = $this->login( $username, $password ) )
    14001553                        return $this->error;
    14011554
     1555                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    14021556                do_action( 'xmlrpc_call', 'wp.getPost' );
    14031557
    14041558                $post = get_post( $post_id, ARRAY_A );
     
    14471601                $password   = $args[2];
    14481602                $filter     = isset( $args[3] ) ? $args[3] : array();
    14491603
    1450                 if ( isset( $args[4] ) )
     1604                if ( isset( $args[4] ) ) {
    14511605                        $fields = $args[4];
    1452                 else
     1606                } else {
     1607                        /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    14531608                        $fields = apply_filters( 'xmlrpc_default_post_fields', array( 'post', 'terms', 'custom_fields' ), 'wp.getPosts' );
     1609                }
    14541610
    14551611                if ( ! $user = $this->login( $username, $password ) )
    14561612                        return $this->error;
    14571613
     1614                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    14581615                do_action( 'xmlrpc_call', 'wp.getPosts' );
    14591616
    14601617                $query = array();
     
    15441701                if ( ! $user = $this->login( $username, $password ) )
    15451702                        return $this->error;
    15461703
     1704                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    15471705                do_action( 'xmlrpc_call', 'wp.newTerm' );
    15481706
    15491707                if ( ! taxonomy_exists( $content_struct['taxonomy'] ) )
     
    16321790                if ( ! $user = $this->login( $username, $password ) )
    16331791                        return $this->error;
    16341792
     1793                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    16351794                do_action( 'xmlrpc_call', 'wp.editTerm' );
    16361795
    16371796                if ( ! taxonomy_exists( $content_struct['taxonomy'] ) )
     
    17241883                if ( ! $user = $this->login( $username, $password ) )
    17251884                        return $this->error;
    17261885
     1886                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    17271887                do_action( 'xmlrpc_call', 'wp.deleteTerm' );
    17281888
    17291889                if ( ! taxonomy_exists( $taxonomy ) )
     
    17911951                if ( ! $user = $this->login( $username, $password ) )
    17921952                        return $this->error;
    17931953
     1954                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    17941955                do_action( 'xmlrpc_call', 'wp.getTerm' );
    17951956
    17961957                if ( ! taxonomy_exists( $taxonomy ) )
     
    18442005                if ( ! $user = $this->login( $username, $password ) )
    18452006                        return $this->error;
    18462007
     2008                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    18472009                do_action( 'xmlrpc_call', 'wp.getTerms' );
    18482010
    18492011                if ( ! taxonomy_exists( $taxonomy ) )
     
    19152077                $password       = $args[2];
    19162078                $taxonomy       = $args[3];
    19172079
    1918                 if ( isset( $args[4] ) )
     2080                if ( isset( $args[4] ) ) {
    19192081                        $fields = $args[4];
    1920                 else
     2082                } else {
     2083                        /**
     2084                         * Filter the taxonomy fields to query for the given XML-RPC method.
     2085                         *
     2086                         * @since 3.4.0
     2087                         *
     2088                         * @param array  $fields Array of taxonomy fields to retrieve.
     2089                         * @param string $method Method name.
     2090                         */
    19212091                        $fields = apply_filters( 'xmlrpc_default_taxonomy_fields', array( 'labels', 'cap', 'object_type' ), 'wp.getTaxonomy' );
     2092                }
    19222093
    19232094                if ( ! $user = $this->login( $username, $password ) )
    19242095                        return $this->error;
    19252096
     2097                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    19262098                do_action( 'xmlrpc_call', 'wp.getTaxonomy' );
    19272099
    19282100                if ( ! taxonomy_exists( $taxonomy ) )
     
    19592131                $password           = $args[2];
    19602132                $filter             = isset( $args[3] ) ? $args[3] : array( 'public' => true );
    19612133
    1962                 if ( isset( $args[4] ) )
     2134                if ( isset( $args[4] ) ) {
    19632135                        $fields = $args[4];
    1964                 else
     2136                } else {
     2137                        /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    19652138                        $fields = apply_filters( 'xmlrpc_default_taxonomy_fields', array( 'labels', 'cap', 'object_type' ), 'wp.getTaxonomies' );
     2139                }
    19662140
    19672141                if ( ! $user = $this->login( $username, $password ) )
    19682142                        return $this->error;
    19692143
     2144                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    19702145                do_action( 'xmlrpc_call', 'wp.getTaxonomies' );
    19712146
    19722147                $taxonomies = get_taxonomies( $filter, 'objects' );
     
    20282203                $password   = $args[2];
    20292204                $user_id    = (int) $args[3];
    20302205
    2031                 if ( isset( $args[4] ) )
     2206                if ( isset( $args[4] ) ) {
    20322207                        $fields = $args[4];
    2033                 else
     2208                } else {
     2209                        /**
     2210                         * Filter the default user fields to query for the given XML-RPC method.
     2211                         *
     2212                         * @since 3.5.0
     2213                         *
     2214                         * @param array  $fields User fields to query for given method. Default 'all'.
     2215                         * @param string $method Method name.
     2216                         */
    20342217                        $fields = apply_filters( 'xmlrpc_default_user_fields', array( 'all' ), 'wp.getUser' );
     2218                }
    20352219
    20362220                if ( ! $user = $this->login( $username, $password ) )
    20372221                        return $this->error;
    20382222
     2223                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    20392224                do_action( 'xmlrpc_call', 'wp.getUser' );
    20402225
    20412226                if ( ! current_user_can( 'edit_user', $user_id ) )
     
    20812266                $password   = $args[2];
    20822267                $filter     = isset( $args[3] ) ? $args[3] : array();
    20832268
    2084                 if ( isset( $args[4] ) )
     2269                if ( isset( $args[4] ) ) {
    20852270                        $fields = $args[4];
    2086                 else
     2271                } else {
     2272                        /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    20872273                        $fields = apply_filters( 'xmlrpc_default_user_fields', array( 'all' ), 'wp.getUsers' );
     2274                }
    20882275
    20892276                if ( ! $user = $this->login( $username, $password ) )
    20902277                        return $this->error;
    20912278
     2279                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    20922280                do_action( 'xmlrpc_call', 'wp.getUsers' );
    20932281
    20942282                if ( ! current_user_can( 'list_users' ) )
     
    21482336                $username   = $args[1];
    21492337                $password   = $args[2];
    21502338
    2151                 if ( isset( $args[3] ) )
     2339                if ( isset( $args[3] ) ) {
    21522340                        $fields = $args[3];
    2153                 else
     2341                } else {
     2342                        /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    21542343                        $fields = apply_filters( 'xmlrpc_default_user_fields', array( 'all' ), 'wp.getProfile' );
     2344                }
    21552345
    21562346                if ( ! $user = $this->login( $username, $password ) )
    21572347                        return $this->error;
    21582348
     2349                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    21592350                do_action( 'xmlrpc_call', 'wp.getProfile' );
    21602351
    21612352                if ( ! current_user_can( 'edit_user', $user->ID ) )
     
    21992390                if ( ! $user = $this->login( $username, $password ) )
    22002391                        return $this->error;
    22012392
     2393                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    22022394                do_action( 'xmlrpc_call', 'wp.editProfile' );
    22032395
    22042396                if ( ! current_user_can( 'edit_user', $user->ID ) )
     
    22722464                if ( !current_user_can( 'edit_page', $page_id ) )
    22732465                        return new IXR_Error( 401, __( 'Sorry, you cannot edit this page.' ) );
    22742466
    2275                 do_action('xmlrpc_call', 'wp.getPage');
     2467                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     2468                do_action( 'xmlrpc_call', 'wp.getPage' );
    22762469
    22772470                // If we found the page then format the data.
    22782471                if ( $page->ID && ($page->post_type == 'page') ) {
     
    23102503                if ( !current_user_can( 'edit_pages' ) )
    23112504                        return new IXR_Error( 401, __( 'Sorry, you cannot edit pages.' ) );
    23122505
    2313                 do_action('xmlrpc_call', 'wp.getPages');
     2506                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     2507                do_action( 'xmlrpc_call', 'wp.getPages' );
    23142508
    23152509                $pages = get_posts( array('post_type' => 'page', 'post_status' => 'any', 'numberposts' => $num_pages) );
    23162510                $num_pages = count($pages);
     
    23502544                if ( !$user = $this->login($username, $password) )
    23512545                        return $this->error;
    23522546
    2353                 do_action('xmlrpc_call', 'wp.newPage');
     2547                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     2548                do_action( 'xmlrpc_call', 'wp.newPage' );
    23542549
    23552550                // Mark this as content for a page.
    23562551                $args[3]["post_type"] = 'page';
     
    23782573                if ( !$user = $this->login($username, $password) )
    23792574                        return $this->error;
    23802575
    2381                 do_action('xmlrpc_call', 'wp.deletePage');
     2576                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     2577                do_action( 'xmlrpc_call', 'wp.deletePage' );
    23822578
    23832579                // Get the current page based on the page_id and
    23842580                // make sure it is a page and not a post.
     
    24202616                if ( !$user = $this->login($username, $password) )
    24212617                        return $this->error;
    24222618
    2423                 do_action('xmlrpc_call', 'wp.editPage');
     2619                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     2620                do_action( 'xmlrpc_call', 'wp.editPage' );
    24242621
    24252622                // Get the page data and make sure it is a page.
    24262623                $actual_page = get_post($page_id, ARRAY_A);
     
    24702667                if ( !current_user_can( 'edit_pages' ) )
    24712668                        return new IXR_Error( 401, __( 'Sorry, you cannot edit pages.' ) );
    24722669
    2473                 do_action('xmlrpc_call', 'wp.getPageList');
     2670                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     2671                do_action( 'xmlrpc_call', 'wp.getPageList' );
    24742672
    24752673                // Get list of pages ids and titles
    24762674                $page_list = $wpdb->get_results("
     
    25212719                if ( !current_user_can('edit_posts') )
    25222720                        return(new IXR_Error(401, __('Sorry, you cannot edit posts on this site.')));
    25232721
    2524                 do_action('xmlrpc_call', 'wp.getAuthors');
     2722                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     2723                do_action( 'xmlrpc_call', 'wp.getAuthors' );
    25252724
    25262725                $authors = array();
    25272726                foreach ( get_users( array( 'fields' => array('ID','user_login','display_name') ) ) as $user ) {
     
    25562755                if ( !current_user_can( 'edit_posts' ) )
    25572756                        return new IXR_Error( 401, __( 'Sorry, you must be able to edit posts on this site in order to view tags.' ) );
    25582757
     2758                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    25592759                do_action( 'xmlrpc_call', 'wp.getKeywords' );
    25602760
    25612761                $tags = array();
     
    25952795                if ( !$user = $this->login($username, $password) )
    25962796                        return $this->error;
    25972797
    2598                 do_action('xmlrpc_call', 'wp.newCategory');
     2798                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     2799                do_action( 'xmlrpc_call', 'wp.newCategory' );
    25992800
    26002801                // Make sure the user is allowed to add a category.
    26012802                if ( !current_user_can('manage_categories') )
     
    26322833                        return(new IXR_Error(500, __('Sorry, the new category failed.')));
    26332834                }
    26342835
     2836                /**
     2837                 * Fires after a new category has successfully been created via XML-RPC.
     2838                 *
     2839                 * @since 3.4.0
     2840                 *
     2841                 * @param int   $cat_id Category ID.
     2842                 * @param array $args   New category arguments.
     2843                 */
    26352844                do_action( 'xmlrpc_call_success_wp_newCategory', $cat_id, $args );
    26362845
    26372846                return $cat_id;
     
    26562865                if ( !$user = $this->login($username, $password) )
    26572866                        return $this->error;
    26582867
    2659                 do_action('xmlrpc_call', 'wp.deleteCategory');
     2868                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     2869                do_action( 'xmlrpc_call', 'wp.deleteCategory' );
    26602870
    26612871                if ( !current_user_can('manage_categories') )
    26622872                        return new IXR_Error( 401, __( 'Sorry, you do not have the right to delete a category.' ) );
    26632873
    26642874                $status = wp_delete_term( $category_id, 'category' );
    26652875
    2666                 if( true == $status )
     2876                if ( true == $status ) {
     2877                        /**
     2878                         * Fires after a category is successfully deleted via XML-RPC.
     2879                         *
     2880                         * @since 3.4.0
     2881                         *
     2882                         * @param int   $category_id ID of the deleted category.
     2883                         * @param array $args        Array of arguments to delete the category.
     2884                         */
    26672885                        do_action( 'xmlrpc_call_success_wp_deleteCategory', $category_id, $args );
     2886                }
    26682887
    26692888                return $status;
    26702889        }
     
    26922911                if ( !current_user_can( 'edit_posts' ) )
    26932912                        return new IXR_Error( 401, __( 'Sorry, you must be able to edit posts to this site in order to view categories.' ) );
    26942913
    2695                 do_action('xmlrpc_call', 'wp.suggestCategories');
     2914                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     2915                do_action( 'xmlrpc_call', 'wp.suggestCategories' );
    26962916
    26972917                $category_suggestions = array();
    26982918                $args = array('get' => 'all', 'number' => $max_results, 'name__like' => $category);
     
    27282948                if ( !current_user_can( 'moderate_comments' ) )
    27292949                        return new IXR_Error( 403, __( 'You are not allowed to moderate comments on this site.' ) );
    27302950
    2731                 do_action('xmlrpc_call', 'wp.getComment');
     2951                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     2952                do_action( 'xmlrpc_call', 'wp.getComment' );
    27322953
    27332954                if ( ! $comment = get_comment($comment_id) )
    27342955                        return new IXR_Error( 404, __( 'Invalid comment ID.' ) );
     
    27692990                if ( !current_user_can( 'moderate_comments' ) )
    27702991                        return new IXR_Error( 401, __( 'Sorry, you cannot edit comments.' ) );
    27712992
    2772                 do_action('xmlrpc_call', 'wp.getComments');
     2993                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     2994                do_action( 'xmlrpc_call', 'wp.getComments' );
    27732995
    27742996                if ( isset($struct['status']) )
    27752997                        $status = $struct['status'];
     
    28353057                if ( !current_user_can( 'edit_comment', $comment_ID ) )
    28363058                        return new IXR_Error( 403, __( 'You are not allowed to moderate comments on this site.' ) );
    28373059
    2838                 do_action('xmlrpc_call', 'wp.deleteComment');
     3060                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     3061                do_action( 'xmlrpc_call', 'wp.deleteComment' );
    28393062
    28403063                $status = wp_delete_comment( $comment_ID );
    28413064
    2842                 if( true == $status )
     3065                if ( true == $status ) {
     3066                        /**
     3067                         * Fires after a comment has successfully been deleted via XML-RPC.
     3068                         *
     3069                         * @since 3.4.0
     3070                         *
     3071                         * @param int   $comment_ID ID of the deleted comment.
     3072                         * @param array $args       Array of arguments to delete the comment.
     3073                         */
    28433074                        do_action( 'xmlrpc_call_success_wp_deleteComment', $comment_ID, $args );
     3075                }
    28443076
    28453077                return $status;
    28463078        }
     
    28903122                if ( !current_user_can( 'edit_comment', $comment_ID ) )
    28913123                        return new IXR_Error( 403, __( 'You are not allowed to moderate comments on this site.' ) );
    28923124
    2893                 do_action('xmlrpc_call', 'wp.editComment');
     3125                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     3126                do_action( 'xmlrpc_call', 'wp.editComment' );
    28943127
    28953128                if ( isset($content_struct['status']) ) {
    28963129                        $statuses = get_comment_statuses();
     
    29313164                if ( !$result )
    29323165                        return new IXR_Error(500, __('Sorry, the comment could not be edited. Something wrong happened.'));
    29333166
     3167                /**
     3168                 * Fires after a comment has been successfully updated via XML-RPC.
     3169                 *
     3170                 * @since 3.4.0
     3171                 *
     3172                 * @param int   $comment_ID ID of the updated comment.
     3173                 * @param array $args       Array of arguments to update the comment.
     3174                 */
    29343175                do_action( 'xmlrpc_call_success_wp_editComment', $comment_ID, $args );
    29353176
    29363177                return true;
     
    29553196                $post           = $args[3];
    29563197                $content_struct = $args[4];
    29573198
    2958                 $allow_anon = apply_filters('xmlrpc_allow_anonymous_comments', false);
     3199                /**
     3200                 * Filter whether to allow anonymous comments over XML-RPC.
     3201                 *
     3202                 * @since 2.7.0
     3203                 *
     3204                 * @param bool $allow Whether to allow anonymous commenting via XML-RPC.
     3205                 *                    Default false.
     3206                 */
     3207                $allow_anon = apply_filters( 'xmlrpc_allow_anonymous_comments', false );
    29593208
    29603209                $user = $this->login($username, $password);
    29613210
     
    30143263
    30153264                $comment['comment_content'] =  isset($content_struct['content']) ? $content_struct['content'] : null;
    30163265
    3017                 do_action('xmlrpc_call', 'wp.newComment');
     3266                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     3267                do_action( 'xmlrpc_call', 'wp.newComment' );
    30183268
    30193269                $comment_ID = wp_new_comment( $comment );
    30203270
     3271                /**
     3272                 * Fires after a new comment is created via XML-RPC.
     3273                 *
     3274                 * @since 3.4.0
     3275                 *
     3276                 * @param int   $comment_ID Comment ID.
     3277                 * @param array $args       Array of new comment arguments.
     3278                 */
    30213279                do_action( 'xmlrpc_call_success_wp_newComment', $comment_ID, $args );
    30223280
    30233281                return $comment_ID;
     
    30443302                if ( !current_user_can( 'moderate_comments' ) )
    30453303                        return new IXR_Error( 403, __( 'You are not allowed access to details about this site.' ) );
    30463304
    3047                 do_action('xmlrpc_call', 'wp.getCommentStatusList');
     3305                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     3306                do_action( 'xmlrpc_call', 'wp.getCommentStatusList' );
    30483307
    30493308                return get_comment_statuses();
    30503309        }
     
    30713330                if ( !current_user_can( 'edit_posts' ) )
    30723331                        return new IXR_Error( 403, __( 'You are not allowed access to details about comments.' ) );
    30733332
    3074                 do_action('xmlrpc_call', 'wp.getCommentCount');
     3333                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     3334                do_action( 'xmlrpc_call', 'wp.getCommentCount' );
    30753335
    30763336                $count = wp_count_comments( $post_id );
    30773337                return array(
     
    31033363                if ( !current_user_can( 'edit_posts' ) )
    31043364                        return new IXR_Error( 403, __( 'You are not allowed access to details about this site.' ) );
    31053365
    3106                 do_action('xmlrpc_call', 'wp.getPostStatusList');
     3366                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     3367                do_action( 'xmlrpc_call', 'wp.getPostStatusList' );
    31073368
    31083369                return get_post_statuses();
    31093370        }
     
    31293390                if ( !current_user_can( 'edit_pages' ) )
    31303391                        return new IXR_Error( 403, __( 'You are not allowed access to details about this site.' ) );
    31313392
    3132                 do_action('xmlrpc_call', 'wp.getPageStatusList');
     3393                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     3394                do_action( 'xmlrpc_call', 'wp.getPageStatusList' );
    31333395
    31343396                return get_page_statuses();
    31353397        }
     
    32863548                if ( !current_user_can( 'upload_files' ) )
    32873549                        return new IXR_Error( 403, __( 'You do not have permission to upload files.' ) );
    32883550
    3289                 do_action('xmlrpc_call', 'wp.getMediaItem');
     3551                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     3552                do_action( 'xmlrpc_call', 'wp.getMediaItem' );
    32903553
    32913554                if ( ! $attachment = get_post($attachment_id) )
    32923555                        return new IXR_Error( 404, __( 'Invalid attachment ID.' ) );
     
    33313594                if ( !current_user_can( 'upload_files' ) )
    33323595                        return new IXR_Error( 401, __( 'You do not have permission to upload files.' ) );
    33333596
    3334                 do_action('xmlrpc_call', 'wp.getMediaLibrary');
     3597                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     3598                do_action( 'xmlrpc_call', 'wp.getMediaLibrary' );
    33353599
    33363600                $parent_id = ( isset($struct['parent_id']) ) ? absint($struct['parent_id']) : '' ;
    33373601                $mime_type = ( isset($struct['mime_type']) ) ? $struct['mime_type'] : '' ;
     
    33723636                if ( !current_user_can( 'edit_posts' ) )
    33733637                        return new IXR_Error( 403, __( 'You are not allowed access to details about this site.' ) );
    33743638
     3639                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    33753640                do_action( 'xmlrpc_call', 'wp.getPostFormats' );
    33763641
    33773642                $formats = get_post_format_strings();
     
    34273692                $password       = $args[2];
    34283693                $post_type_name = $args[3];
    34293694
    3430                 if ( isset( $args[4] ) )
     3695                if ( isset( $args[4] ) ) {
    34313696                        $fields = $args[4];
    3432                 else
     3697                } else {
     3698                        /**
     3699                         * Filter the default fields to query for the given XML-RPC method.
     3700                         *
     3701                         * @since 3.4.0
     3702                         *
     3703                         * @param array  $fields Array of post type fields to query for the given method.
     3704                         * @param string $method Method name.
     3705                         */
    34333706                        $fields = apply_filters( 'xmlrpc_default_posttype_fields', array( 'labels', 'cap', 'taxonomies' ), 'wp.getPostType' );
     3707                }
    34343708
    34353709                if ( !$user = $this->login( $username, $password ) )
    34363710                        return $this->error;
    34373711
     3712                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    34383713                do_action( 'xmlrpc_call', 'wp.getPostType' );
    34393714
    34403715                if( ! post_type_exists( $post_type_name ) )
     
    34733748                $password           = $args[2];
    34743749                $filter             = isset( $args[3] ) ? $args[3] : array( 'public' => true );
    34753750
    3476                 if ( isset( $args[4] ) )
     3751                if ( isset( $args[4] ) ) {
    34773752                        $fields = $args[4];
    3478                 else
     3753                } else {
     3754                        /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    34793755                        $fields = apply_filters( 'xmlrpc_default_posttype_fields', array( 'labels', 'cap', 'taxonomies' ), 'wp.getPostTypes' );
     3756                }
    34803757
    34813758                if ( ! $user = $this->login( $username, $password ) )
    34823759                        return $this->error;
    34833760
     3761                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    34843762                do_action( 'xmlrpc_call', 'wp.getPostTypes' );
    34853763
    34863764                $post_types = get_post_types( $filter, 'objects' );
     
    35273805                $password   = $args[2];
    35283806                $post_id    = (int) $args[3];
    35293807
    3530                 if ( isset( $args[4] ) )
     3808                if ( isset( $args[4] ) ) {
    35313809                        $fields = $args[4];
    3532                 else
     3810                } else {
     3811                        /**
     3812                         * Filter the default revision fields to query for the given XML-RPC method.
     3813                         *
     3814                         * @since 3.5.0
     3815                         *
     3816                         * @param array  $field  Array of revision fields to query for the given method.
     3817                         * @param string $method Method name.
     3818                         */
    35333819                        $fields = apply_filters( 'xmlrpc_default_revision_fields', array( 'post_date', 'post_date_gmt' ), 'wp.getRevisions' );
     3820                }
    35343821
    35353822                if ( ! $user = $this->login( $username, $password ) )
    35363823                        return $this->error;
    35373824
     3825                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    35383826                do_action( 'xmlrpc_call', 'wp.getRevisions' );
    35393827
    35403828                if ( ! $post = get_post( $post_id ) )
     
    35963884                if ( ! $user = $this->login( $username, $password ) )
    35973885                        return $this->error;
    35983886
     3887                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    35993888                do_action( 'xmlrpc_call', 'wp.restoreRevision' );
    36003889
    36013890                if ( ! $revision = wp_get_post_revision( $revision_id ) )
     
    36453934                if ( !$user = $this->login($username, $password) )
    36463935                        return $this->error;
    36473936
    3648                 do_action('xmlrpc_call', 'blogger.getUsersBlogs');
     3937                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     3938                do_action( 'xmlrpc_call', 'blogger.getUsersBlogs' );
    36493939
    36503940                $is_admin = current_user_can('manage_options');
    36513941
     
    37124002                if ( !current_user_can( 'edit_posts' ) )
    37134003                        return new IXR_Error( 401, __( 'Sorry, you do not have access to user data on this site.' ) );
    37144004
    3715                 do_action('xmlrpc_call', 'blogger.getUserInfo');
     4005                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     4006                do_action( 'xmlrpc_call', 'blogger.getUserInfo' );
    37164007
    37174008                $struct = array(
    37184009                        'nickname'  => $user->nickname,
     
    37514042                if ( !current_user_can( 'edit_post', $post_ID ) )
    37524043                        return new IXR_Error( 401, __( 'Sorry, you cannot edit this post.' ) );
    37534044
    3754                 do_action('xmlrpc_call', 'blogger.getPost');
     4045                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     4046                do_action( 'xmlrpc_call', 'blogger.getPost' );
    37554047
    37564048                $categories = implode(',', wp_get_post_categories($post_ID));
    37574049
     
    37964088                if ( ! current_user_can( 'edit_posts' ) )
    37974089                        return new IXR_Error( 401, __( 'Sorry, you cannot edit posts on this site.' ) );
    37984090
    3799                 do_action('xmlrpc_call', 'blogger.getRecentPosts');
     4091                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     4092                do_action( 'xmlrpc_call', 'blogger.getRecentPosts' );
    38004093
    38014094                $posts_list = wp_get_recent_posts( $query );
    38024095
     
    38744167                if ( !$user = $this->login($username, $password) )
    38754168                        return $this->error;
    38764169
    3877                 do_action('xmlrpc_call', 'blogger.newPost');
     4170                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     4171                do_action( 'xmlrpc_call', 'blogger.newPost' );
    38784172
    38794173                $cap = ($publish) ? 'publish_posts' : 'edit_posts';
    38804174                if ( ! current_user_can( get_post_type_object( 'post' )->cap->create_posts ) || !current_user_can($cap) )
     
    39024196
    39034197                $this->attach_uploads( $post_ID, $post_content );
    39044198
     4199                /**
     4200                 * Fires after a post is successfully created via the XML-RPC Blogger API.
     4201                 *
     4202                 * @since 3.4.0
     4203                 *
     4204                 * @param int   $post_ID New post ID.
     4205                 * @param array $args    Array of new post arguments.
     4206                 */
    39054207                do_action( 'xmlrpc_call_success_blogger_newPost', $post_ID, $args );
    39064208
    39074209                return $post_ID;
     
    39284230                if ( !$user = $this->login($username, $password) )
    39294231                        return $this->error;
    39304232
    3931                 do_action('xmlrpc_call', 'blogger.editPost');
     4233                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     4234                do_action( 'xmlrpc_call', 'blogger.editPost' );
    39324235
    39334236                $actual_post = get_post($post_ID,ARRAY_A);
    39344237
     
    39584261
    39594262                $this->attach_uploads( $ID, $post_content );
    39604263
     4264                /**
     4265                 * Fires after a post has been successfully updated via the XML-RPC Blogger API.
     4266                 *
     4267                 * @since 3.4.0
     4268                 *
     4269                 * @param int   $post_ID Post ID.
     4270                 * @param array $args    Array of arguments for the post to edit.
     4271                 */
    39614272                do_action( 'xmlrpc_call_success_blogger_editPost', $post_ID, $args );
    39624273
    39634274                return true;
     
    39824293                if ( !$user = $this->login($username, $password) )
    39834294                        return $this->error;
    39844295
    3985                 do_action('xmlrpc_call', 'blogger.deletePost');
     4296                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     4297                do_action( 'xmlrpc_call', 'blogger.deletePost' );
    39864298
    39874299                $actual_post = get_post($post_ID,ARRAY_A);
    39884300
     
    39974309                if ( !$result )
    39984310                        return new IXR_Error(500, __('For some strange yet very annoying reason, this post could not be deleted.'));
    39994311
     4312                /**
     4313                 * Fires after a post has been successfully deleted via the XML-RPC Blogger API.
     4314                 *
     4315                 * @since 3.4.0
     4316                 *
     4317                 * @param int   $post_ID ID of the deleted post.
     4318                 * @param array $args    Array of arguments to delete the post.
     4319                 */
    40004320                do_action( 'xmlrpc_call_success_blogger_deletePost', $post_ID, $args );
    40014321
    40024322                return true;
     
    40534373                if ( !$user = $this->login($username, $password) )
    40544374                        return $this->error;
    40554375
    4056                 do_action('xmlrpc_call', 'metaWeblog.newPost');
     4376                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     4377                do_action( 'xmlrpc_call', 'metaWeblog.newPost' );
    40574378
    40584379                $page_template = '';
    40594380                if ( !empty( $content_struct['post_type'] ) ) {
     
    43074628                if ( !$post_ID )
    43084629                        return new IXR_Error(500, __('Sorry, your entry could not be posted. Something wrong happened.'));
    43094630
     4631                /**
     4632                 * Fires after a new post has successfully been created via the XML-RPC MovableType API.
     4633                 *
     4634                 * @since 3.4.0
     4635                 *
     4636                 * @param int   $post_ID ID of the new post.
     4637                 * @param array $args    Arguments to create the new post.
     4638                 */
    43104639                do_action( 'xmlrpc_call_success_mw_newPost', $post_ID, $args );
    43114640
    43124641                return strval($post_ID);
     
    43724701                if ( ! $user = $this->login($username, $password) )
    43734702                        return $this->error;
    43744703
    4375                 do_action('xmlrpc_call', 'metaWeblog.editPost');
     4704                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     4705                do_action( 'xmlrpc_call', 'metaWeblog.editPost' );
    43764706
    43774707                $postdata = get_post( $post_ID, ARRAY_A );
    43784708
     
    46154945                if ( isset( $content_struct['wp_post_format'] ) )
    46164946                        set_post_format( $post_ID, $content_struct['wp_post_format'] );
    46174947
     4948                /**
     4949                 * Fires after a post has been successfully updated via the XML-RPC MovableType API.
     4950                 *
     4951                 * @since 3.4.0
     4952                 *
     4953                 * @param int   $post_ID ID of the updated post.
     4954                 * @param array $args    Array of arguments to update the post.
     4955                 */
    46184956                do_action( 'xmlrpc_call_success_mw_editPost', $post_ID, $args );
    46194957
    46204958                return true;
     
    46464984                if ( !current_user_can( 'edit_post', $post_ID ) )
    46474985                        return new IXR_Error( 401, __( 'Sorry, you cannot edit this post.' ) );
    46484986
    4649                 do_action('xmlrpc_call', 'metaWeblog.getPost');
     4987                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     4988                do_action( 'xmlrpc_call', 'metaWeblog.getPost' );
    46504989
    46514990                if ($postdata['post_date'] != '') {
    46524991                        $post_date = $this->_convert_date( $postdata['post_date'] );
     
    47705109                if ( ! current_user_can( 'edit_posts' ) )
    47715110                        return new IXR_Error( 401, __( 'Sorry, you cannot edit posts on this site.' ) );
    47725111
    4773                 do_action('xmlrpc_call', 'metaWeblog.getRecentPosts');
     5112                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     5113                do_action( 'xmlrpc_call', 'metaWeblog.getRecentPosts' );
    47745114
    47755115                $posts_list = wp_get_recent_posts( $query );
    47765116
     
    48855225                if ( !current_user_can( 'edit_posts' ) )
    48865226                        return new IXR_Error( 401, __( 'Sorry, you must be able to edit posts on this site in order to view categories.' ) );
    48875227
    4888                 do_action('xmlrpc_call', 'metaWeblog.getCategories');
     5228                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     5229                do_action( 'xmlrpc_call', 'metaWeblog.getCategories' );
    48895230
    48905231                $categories_struct = array();
    48915232
     
    49335274                if ( !$user = $this->login($username, $password) )
    49345275                        return $this->error;
    49355276
    4936                 do_action('xmlrpc_call', 'metaWeblog.newMediaObject');
     5277                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     5278                do_action( 'xmlrpc_call', 'metaWeblog.newMediaObject' );
    49375279
    49385280                if ( !current_user_can('upload_files') ) {
    49395281                        $this->error = new IXR_Error( 401, __( 'You do not have permission to upload files.' ) );
    49405282                        return $this->error;
    49415283                }
    49425284
    4943                 if ( $upload_err = apply_filters( 'pre_upload_error', false ) )
    4944                         return new IXR_Error(500, $upload_err);
     5285                /**
     5286                 * Filter whether to pre-empt the XML-RPC media upload.
     5287                 *
     5288                 * Passing a truthy value will effectively short-circuit the media upload,
     5289                 * returning that value as a 500 error instead.
     5290                 *
     5291                 * @since 2.1.0
     5292                 *
     5293                 * @param bool $error Whether to pre-empt the media upload. Default false.
     5294                 */
     5295                if ( $upload_err = apply_filters( 'pre_upload_error', false ) ) {
     5296                        return new IXR_Error( 500, $upload_err );
     5297                }
    49455298
    49465299                if ( !empty($data['overwrite']) && ($data['overwrite'] == true) ) {
    49475300                        // Get postmeta info on the object.
     
    49875340                $id = wp_insert_attachment( $attachment, $upload[ 'file' ], $post_id );
    49885341                wp_update_attachment_metadata( $id, wp_generate_attachment_metadata( $id, $upload['file'] ) );
    49895342
     5343                /**
     5344                 * Fires after a new attachment has been added via the XML-RPC MovableType API.
     5345                 *
     5346                 * @since 3.4.0
     5347                 *
     5348                 * @param int   $id   ID of the new attachment.
     5349                 * @param array $args Array of arguments to add the attachment.
     5350                 */
    49905351                do_action( 'xmlrpc_call_success_mw_newMediaObject', $id, $args );
    49915352
    49925353                $struct = array(
     
    50275388                if ( !$user = $this->login($username, $password) )
    50285389                        return $this->error;
    50295390
    5030                 do_action('xmlrpc_call', 'mt.getRecentPostTitles');
     5391                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     5392                do_action( 'xmlrpc_call', 'mt.getRecentPostTitles' );
    50315393
    50325394                $posts_list = wp_get_recent_posts( $query );
    50335395
     
    50865448                if ( !current_user_can( 'edit_posts' ) )
    50875449                        return new IXR_Error( 401, __( 'Sorry, you must be able to edit posts on this site in order to view categories.' ) );
    50885450
    5089                 do_action('xmlrpc_call', 'mt.getCategoryList');
     5451                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     5452                do_action( 'xmlrpc_call', 'mt.getCategoryList' );
    50905453
    50915454                $categories_struct = array();
    50925455
     
    51275490                if ( !current_user_can( 'edit_post', $post_ID ) )
    51285491                        return new IXR_Error( 401, __( 'Sorry, you can not edit this post.' ) );
    51295492
    5130                 do_action('xmlrpc_call', 'mt.getPostCategories');
     5493                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     5494                do_action( 'xmlrpc_call', 'mt.getPostCategories' );
    51315495
    51325496                $categories = array();
    51335497                $catids = wp_get_post_categories(intval($post_ID));
     
    51655529                if ( !$user = $this->login($username, $password) )
    51665530                        return $this->error;
    51675531
    5168                 do_action('xmlrpc_call', 'mt.setPostCategories');
     5532                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     5533                do_action( 'xmlrpc_call', 'mt.setPostCategories' );
    51695534
    51705535                if ( ! get_post( $post_ID ) )
    51715536                        return new IXR_Error( 404, __( 'Invalid post ID.' ) );
     
    51935558         */
    51945559        function mt_supportedMethods($args) {
    51955560
    5196                 do_action('xmlrpc_call', 'mt.supportedMethods');
     5561                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     5562                do_action( 'xmlrpc_call', 'mt.supportedMethods' );
    51975563
    51985564                $supported_methods = array();
    51995565                foreach ( $this->methods as $key => $value ) {
     
    52115577         * @param array $args Method parameters.
    52125578         */
    52135579        function mt_supportedTextFilters($args) {
    5214                 do_action('xmlrpc_call', 'mt.supportedTextFilters');
    5215                 return apply_filters('xmlrpc_text_filters', array());
     5580                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     5581                do_action( 'xmlrpc_call', 'mt.supportedTextFilters' );
     5582
     5583                /**
     5584                 * Filter the MoveableType text filters list for XML-RPC.
     5585                 *
     5586                 * @since 2.2.0
     5587                 *
     5588                 * @param array $filters List of text filters.
     5589                 */
     5590                return apply_filters( 'xmlrpc_text_filters', array() );
    52165591        }
    52175592
    52185593        /**
     
    52295604
    52305605                $post_ID = intval($args);
    52315606
    5232                 do_action('xmlrpc_call', 'mt.getTrackbackPings');
     5607                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     5608                do_action( 'xmlrpc_call', 'mt.getTrackbackPings' );
    52335609
    52345610                $actual_post = get_post($post_ID, ARRAY_A);
    52355611
     
    52765652                if ( !$user = $this->login($username, $password) )
    52775653                        return $this->error;
    52785654
    5279                 do_action('xmlrpc_call', 'mt.publishPost');
     5655                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     5656                do_action( 'xmlrpc_call', 'mt.publishPost' );
    52805657
    52815658                $postdata = get_post($post_ID, ARRAY_A);
    52825659                if ( ! $postdata )
     
    53125689        function pingback_ping($args) {
    53135690                global $wpdb;
    53145691
    5315                 do_action('xmlrpc_call', 'pingback.ping');
     5692                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     5693                do_action( 'xmlrpc_call', 'pingback.ping' );
    53165694
    53175695                $this->escape($args);
    53185696
     
    53255703                $pagelinkedto = str_replace('&', '&', $pagelinkedto);
    53265704                $pagelinkedto = str_replace('&', '&', $pagelinkedto);
    53275705
     5706                /**
     5707                 * Filter the pingback source URI.
     5708                 *
     5709                 * @since 3.6.0
     5710                 *
     5711                 * @param string $pagelinkedfrom URI of the page linked from.
     5712                 * @param string $pagelinkedto   URI of the page linked to.
     5713                 */
    53285714                $pagelinkedfrom = apply_filters( 'pingback_ping_source_uri', $pagelinkedfrom, $pagelinkedto );
     5715
    53295716                if ( ! $pagelinkedfrom )
    53305717                        return $this->pingback_error( 0, __( 'A valid URL was not provided.' ) );
    53315718
     
    54065793                if ( !$linea )
    54075794                        return $this->pingback_error( 16, __( 'The source URL does not exist.' ) );
    54085795
    5409                 $linea = apply_filters('pre_remote_source', $linea, $pagelinkedto);
     5796                /**
     5797                 * Filter the pingback remote source.
     5798                 *
     5799                 * @since 2.5.0
     5800                 *
     5801                 * @param string $linea        Response object for the page linked from.
     5802                 * @param string $pagelinkedto URL of the page linked to.
     5803                 */
     5804                $linea = apply_filters( 'pre_remote_source', $linea, $pagelinkedto );
    54105805
    54115806                // Work around bug in strip_tags():
    54125807                $linea = str_replace('<!DOC', '<DOC', $linea);
     
    54715866                $commentdata = compact('comment_post_ID', 'comment_author', 'comment_author_url', 'comment_author_email', 'comment_content', 'comment_type');
    54725867
    54735868                $comment_ID = wp_new_comment($commentdata);
    5474                 do_action('pingback_post', $comment_ID);
    54755869
     5870                /**
     5871                 * Fires after a post pingback has been sent.
     5872                 *
     5873                 * @since 0.71
     5874                 *
     5875                 * @param int $comment_ID Comment ID.
     5876                 */
     5877                do_action( 'pingback_post', $comment_ID );
     5878
    54765879                return sprintf(__('Pingback from %1$s to %2$s registered. Keep the web talking! :-)'), $pagelinkedfrom, $pagelinkedto);
    54775880        }
    54785881
     
    54905893
    54915894                global $wpdb;
    54925895
    5493                 do_action('xmlrpc_call', 'pingback.extensions.getPingbacks');
     5896                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
     5897                do_action( 'xmlrpc_call', 'pingback.extensions.getPingbacks' );
    54945898
    54955899                $this->escape($args);
    54965900
     
    55245928        }
    55255929
    55265930        protected function pingback_error( $code, $message ) {
     5931                /**
     5932                 * Filter the XML-RPC pingback error return.
     5933                 *
     5934                 * @since 3.5.1
     5935                 *
     5936                 * @param IXR_Error $error An IXR_Error object containing the error code and message.
     5937                 */
    55275938                return apply_filters( 'xmlrpc_pingback_error', new IXR_Error( $code, $message ) );
    55285939        }
    55295940}