WordPress.org
Get WordPress

Make WordPress Core

Changeset 15648


Ignore:
Timestamp:
09/23/2010 09:38:28 PM (16 years ago)
Author:
westi
Message:

Complete the move to a seperate class file for #14820 props filosofo.
Add support for replacing the class used. Fixes #14814 props filosofo.

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed

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

    r15647 r15648  
    55 * @package WordPress
    66 */
    7 
    8 /**
    9  * Whether this is a XMLRPC Request
    10  *
    11  * @var bool
    12  */
    13 define('XMLRPC_REQUEST', true);
    14 
    15 // Some browser-embedded clients send cookies. We don't want them.
    16 $_COOKIE = array();
    17 
    18 // A bug in PHP < 5.2.2 makes $HTTP_RAW_POST_DATA not set by default,
    19 // but we can do it ourself.
    20 if ( !isset( $HTTP_RAW_POST_DATA ) ) {
    21         $HTTP_RAW_POST_DATA = file_get_contents( 'php://input' );
    22 }
    23 
    24 // fix for mozBlog and other cases where '<?xml' isn't on the very first line
    25 if ( isset($HTTP_RAW_POST_DATA) )
    26         $HTTP_RAW_POST_DATA = trim($HTTP_RAW_POST_DATA);
    27 
    28 /** Include the bootstrap for setting up WordPress environment */
    29 include('./wp-load.php');
    30 
    31 if ( isset( $_GET['rsd'] ) ) { // http://archipelago.phrasewise.com/rsd
    32 header('Content-Type: text/xml; charset=' . get_option('blog_charset'), true);
    33 ?>
    34 <?php echo '<?xml version="1.0" encoding="'.get_option('blog_charset').'"?'.'>'; ?>
    35 <rsd version="1.0" xmlns="http://archipelago.phrasewise.com/rsd">
    36   <service>
    37     <engineName>WordPress</engineName>
    38     <engineLink>http://wordpress.org/</engineLink>
    39     <homePageLink><?php bloginfo_rss('url') ?></homePageLink>
    40     <apis>
    41       <api name="WordPress" blogID="1" preferred="true" apiLink="<?php echo site_url('xmlrpc.php', 'rpc') ?>" />
    42       <api name="Movable Type" blogID="1" preferred="false" apiLink="<?php echo site_url('xmlrpc.php', 'rpc') ?>" />
    43       <api name="MetaWeblog" blogID="1" preferred="false" apiLink="<?php echo site_url('xmlrpc.php', 'rpc') ?>" />
    44       <api name="Blogger" blogID="1" preferred="false" apiLink="<?php echo site_url('xmlrpc.php', 'rpc') ?>" />
    45       <api name="Atom" blogID="" preferred="false" apiLink="<?php echo apply_filters('atom_service_url', site_url('wp-app.php/service', 'rpc') ) ?>" />
    46     </apis>
    47   </service>
    48 </rsd>
    49 <?php
    50 exit;
    51 }
    52 
    53 include_once(ABSPATH . 'wp-admin/includes/admin.php');
    54 include_once(ABSPATH . WPINC . '/class-IXR.php');
    55 
    56 // Turn off all warnings and errors.
    57 // error_reporting(0);
    58 
    59 /**
    60  * Posts submitted via the xmlrpc interface get that title
    61  * @name post_default_title
    62  * @var string
    63  */
    64 $post_default_title = "";
    65 
    66 /**
    67  * Whether to enable XMLRPC Logging.
    68  *
    69  * @name xmlrpc_logging
    70  * @var int|bool
    71  */
    72 $xmlrpc_logging = 0;
    73 
    74 /**
    75  * logIO() - Writes logging info to a file.
    76  *
    77  * @uses $xmlrpc_logging
    78  * @package WordPress
    79  * @subpackage Logging
    80  *
    81  * @param string $io Whether input or output
    82  * @param string $msg Information describing logging reason.
    83  * @return bool Always return true
    84  */
    85 function logIO($io,$msg) {
    86         global $xmlrpc_logging;
    87         if ($xmlrpc_logging) {
    88                 $fp = fopen("../xmlrpc.log","a+");
    89                 $date = gmdate("Y-m-d H:i:s ");
    90                 $iot = ($io == "I") ? " Input: " : " Output: ";
    91                 fwrite($fp, "\n\n".$date.$iot.$msg);
    92                 fclose($fp);
    93         }
    94         return true;
    95 }
    96 
    97 if ( isset($HTTP_RAW_POST_DATA) )
    98         logIO("I", $HTTP_RAW_POST_DATA);
    997
    1008/**
    … …  
    33363244        }
    33373245}
    3338 
    3339 $wp_xmlrpc_server = new wp_xmlrpc_server();
    3340 $wp_xmlrpc_server->serve_request();
    33413246?>

  • trunk/xmlrpc.php

    r15567 r15648  
    5353include_once(ABSPATH . 'wp-admin/includes/admin.php');
    5454include_once(ABSPATH . WPINC . '/class-IXR.php');
     55include_once(ABSPATH . WPINC . '/class.wp-xmlrpc-server.php');
    5556
    5657// Turn off all warnings and errors.
    … …  
    9899        logIO("I", $HTTP_RAW_POST_DATA);
    99100
    100 /**
    101  * WordPress XMLRPC server implementation.
    102  *
    103  * Implements compatability for Blogger API, MetaWeblog API, MovableType, and
    104  * pingback. Additional WordPress API for managing comments, pages, posts,
    105  * options, etc.
    106  *
    107  * Since WordPress 2.6.0, WordPress XMLRPC server can be disabled in the
    108  * administration panels.
    109  *
    110  * @package WordPress
    111  * @subpackage Publishing
    112  * @since 1.5.0
    113  */
    114 class wp_xmlrpc_server extends IXR_Server {
     101// Allow for a plugin to insert a different class to handle requests.
     102$wp_xmlrpc_server_class = apply_filters('wp_xmlrpc_server_class', 'wp_xmlrpc_server');
     103$wp_xmlrpc_server = new $wp_xmlrpc_server_class;
    115104
    116         /**
    117          * Register all of the XMLRPC methods that XMLRPC server understands.
    118          *
    119          * PHP4 constructor and sets up server and method property. Passes XMLRPC
    120          * methods through the 'xmlrpc_methods' filter to allow plugins to extend
    121          * or replace XMLRPC methods.
    122          *
    123          * @since 1.5.0
    124          *
    125          * @return wp_xmlrpc_server
    126          */
    127         function wp_xmlrpc_server() {
    128                 $this->methods = array(
    129                         // WordPress API
    130                         'wp.getUsersBlogs'              => 'this:wp_getUsersBlogs',
    131                         'wp.getPage'                    => 'this:wp_getPage',
    132                         'wp.getPages'                   => 'this:wp_getPages',
    133                         'wp.newPage'                    => 'this:wp_newPage',
    134                         'wp.deletePage'                 => 'this:wp_deletePage',
    135                         'wp.editPage'                   => 'this:wp_editPage',
    136                         'wp.getPageList'                => 'this:wp_getPageList',
    137                         'wp.getAuthors'                 => 'this:wp_getAuthors',
    138                         'wp.getCategories'              => 'this:mw_getCategories',             // Alias
    139                         'wp.getTags'                    => 'this:wp_getTags',
    140                         'wp.newCategory'                => 'this:wp_newCategory',
    141                         'wp.deleteCategory'             => 'this:wp_deleteCategory',
    142                         'wp.suggestCategories'  => 'this:wp_suggestCategories',
    143                         'wp.uploadFile'                 => 'this:mw_newMediaObject',    // Alias
    144                         'wp.getCommentCount'    => 'this:wp_getCommentCount',
    145                         'wp.getPostStatusList'  => 'this:wp_getPostStatusList',
    146                         'wp.getPageStatusList'  => 'this:wp_getPageStatusList',
    147                         'wp.getPageTemplates'   => 'this:wp_getPageTemplates',
    148                         'wp.getOptions'                 => 'this:wp_getOptions',
    149                         'wp.setOptions'                 => 'this:wp_setOptions',
    150                         'wp.getComment'                 => 'this:wp_getComment',
    151                         'wp.getComments'                => 'this:wp_getComments',
    152                         'wp.deleteComment'              => 'this:wp_deleteComment',
    153                         'wp.editComment'                => 'this:wp_editComment',
    154                         'wp.newComment'                 => 'this:wp_newComment',
    155                         'wp.getCommentStatusList' => 'this:wp_getCommentStatusList',
    156 
    157                         // Blogger API
    158                         'blogger.getUsersBlogs' => 'this:blogger_getUsersBlogs',
    159                         'blogger.getUserInfo' => 'this:blogger_getUserInfo',
    160                         'blogger.getPost' => 'this:blogger_getPost',
    161                         'blogger.getRecentPosts' => 'this:blogger_getRecentPosts',
    162                         'blogger.getTemplate' => 'this:blogger_getTemplate',
    163                         'blogger.setTemplate' => 'this:blogger_setTemplate',
    164                         'blogger.newPost' => 'this:blogger_newPost',
    165                         'blogger.editPost' => 'this:blogger_editPost',
    166                         'blogger.deletePost' => 'this:blogger_deletePost',
    167 
    168                         // MetaWeblog API (with MT extensions to structs)
    169                         'metaWeblog.newPost' => 'this:mw_newPost',
    170                         'metaWeblog.editPost' => 'this:mw_editPost',
    171                         'metaWeblog.getPost' => 'this:mw_getPost',
    172                         'metaWeblog.getRecentPosts' => 'this:mw_getRecentPosts',
    173                         'metaWeblog.getCategories' => 'this:mw_getCategories',
    174                         'metaWeblog.newMediaObject' => 'this:mw_newMediaObject',
    175 
    176                         // MetaWeblog API aliases for Blogger API
    177                         // see http://www.xmlrpc.com/stories/storyReader$2460
    178                         'metaWeblog.deletePost' => 'this:blogger_deletePost',
    179                         'metaWeblog.getTemplate' => 'this:blogger_getTemplate',
    180                         'metaWeblog.setTemplate' => 'this:blogger_setTemplate',
    181                         'metaWeblog.getUsersBlogs' => 'this:blogger_getUsersBlogs',
    182 
    183                         // MovableType API
    184                         'mt.getCategoryList' => 'this:mt_getCategoryList',
    185                         'mt.getRecentPostTitles' => 'this:mt_getRecentPostTitles',
    186                         'mt.getPostCategories' => 'this:mt_getPostCategories',
    187                         'mt.setPostCategories' => 'this:mt_setPostCategories',
    188                         'mt.supportedMethods' => 'this:mt_supportedMethods',
    189                         'mt.supportedTextFilters' => 'this:mt_supportedTextFilters',
    190                         'mt.getTrackbackPings' => 'this:mt_getTrackbackPings',
    191                         'mt.publishPost' => 'this:mt_publishPost',
    192 
    193                         // PingBack
    194                         'pingback.ping' => 'this:pingback_ping',
    195                         'pingback.extensions.getPingbacks' => 'this:pingback_extensions_getPingbacks',
    196 
    197                         'demo.sayHello' => 'this:sayHello',
    198                         'demo.addTwoNumbers' => 'this:addTwoNumbers'
    199                 );
    200 
    201                 $this->initialise_blog_option_info( );
    202                 $this->methods = apply_filters('xmlrpc_methods', $this->methods);
    203         }
    204 
    205         function serve_request() {
    206                 $this->IXR_Server($this->methods);
    207         }
    208 
    209         /**
    210          * Test XMLRPC API by saying, "Hello!" to client.
    211          *
    212          * @since 1.5.0
    213          *
    214          * @param array $args Method Parameters.
    215          * @return string
    216          */
    217         function sayHello($args) {
    218                 return 'Hello!';
    219         }
    220 
    221         /**
    222          * Test XMLRPC API by adding two numbers for client.
    223          *
    224          * @since 1.5.0
    225          *
    226          * @param array $args Method Parameters.
    227          * @return int
    228          */
    229         function addTwoNumbers($args) {
    230                 $number1 = $args[0];
    231                 $number2 = $args[1];
    232                 return $number1 + $number2;
    233         }
    234 
    235         /**
    236          * Check user's credentials.
    237          *
    238          * @since 1.5.0
    239          *
    240          * @param string $user_login User's username.
    241          * @param string $user_pass User's password.
    242          * @return bool Whether authentication passed.
    243          * @deprecated use wp_xmlrpc_server::login
    244          * @see wp_xmlrpc_server::login
    245          */
    246         function login_pass_ok($user_login, $user_pass) {
    247                 if ( !get_option( 'enable_xmlrpc' ) ) {
    248                         $this->error = new IXR_Error( 405, sprintf( __( 'XML-RPC services are disabled on this site.  An admin user can enable them at %s'),  admin_url('options-writing.php') ) );
    249                         return false;
    250                 }
    251 
    252                 if (!user_pass_ok($user_login, $user_pass)) {
    253                         $this->error = new IXR_Error(403, __('Bad login/pass combination.'));
    254                         return false;
    255                 }
    256                 return true;
    257         }
    258 
    259         /**
    260          * Log user in.
    261          *
    262          * @since 2.8
    263          *
    264          * @param string $username User's username.
    265          * @param string $password User's password.
    266          * @return mixed WP_User object if authentication passed, false otherwise
    267          */
    268         function login($username, $password) {
    269                 if ( !get_option( 'enable_xmlrpc' ) ) {
    270                         $this->error = new IXR_Error( 405, sprintf( __( 'XML-RPC services are disabled on this site.  An admin user can enable them at %s'),  admin_url('options-writing.php') ) );
    271                         return false;
    272                 }
    273 
    274                 $user = wp_authenticate($username, $password);
    275 
    276                 if (is_wp_error($user)) {
    277                         $this->error = new IXR_Error(403, __('Bad login/pass combination.'));
    278                         return false;
    279                 }
    280 
    281                 wp_set_current_user( $user->ID );
    282                 return $user;
    283         }
    284 
    285         /**
    286          * Sanitize string or array of strings for database.
    287          *
    288          * @since 1.5.2
    289          *
    290          * @param string|array $array Sanitize single string or array of strings.
    291          * @return string|array Type matches $array and sanitized for the database.
    292          */
    293         function escape(&$array) {
    294                 global $wpdb;
    295 
    296                 if (!is_array($array)) {
    297                         return($wpdb->escape($array));
    298                 } else {
    299                         foreach ( (array) $array as $k => $v ) {
    300                                 if ( is_array($v) ) {
    301                                         $this->escape($array[$k]);
    302                                 } else if ( is_object($v) ) {
    303                                         //skip
    304                                 } else {
    305                                         $array[$k] = $wpdb->escape($v);
    306                                 }
    307                         }
    308                 }
    309         }
    310 
    311         /**
    312          * Retrieve custom fields for post.
    313          *
    314          * @since 2.5.0
    315          *
    316          * @param int $post_id Post ID.
    317          * @return array Custom fields, if exist.
    318          */
    319         function get_custom_fields($post_id) {
    320                 $post_id = (int) $post_id;
    321 
    322                 $custom_fields = array();
    323 
    324                 foreach ( (array) has_meta($post_id) as $meta ) {
    325                         // Don't expose protected fields.
    326                         if ( strpos($meta['meta_key'], '_wp_') === 0 ) {
    327                                 continue;
    328                         }
    329 
    330                         $custom_fields[] = array(
    331                                 "id"    => $meta['meta_id'],
    332                                 "key"   => $meta['meta_key'],
    333                                 "value" => $meta['meta_value']
    334                         );
    335                 }
    336 
    337                 return $custom_fields;
    338         }
    339 
    340         /**
    341          * Set custom fields for post.
    342          *
    343          * @since 2.5.0
    344          *
    345          * @param int $post_id Post ID.
    346          * @param array $fields Custom fields.
    347          */
    348         function set_custom_fields($post_id, $fields) {
    349                 $post_id = (int) $post_id;
    350 
    351                 foreach ( (array) $fields as $meta ) {
    352                         if ( isset($meta['id']) ) {
    353                                 $meta['id'] = (int) $meta['id'];
    354 
    355                                 if ( isset($meta['key']) ) {
    356                                         update_meta($meta['id'], $meta['key'], $meta['value']);
    357                                 }
    358                                 else {
    359                                         delete_meta($meta['id']);
    360                                 }
    361                         }
    362                         else {
    363                                 $_POST['metakeyinput'] = $meta['key'];
    364                                 $_POST['metavalue'] = $meta['value'];
    365                                 add_meta($post_id);
    366                         }
    367                 }
    368         }
    369 
    370         /**
    371          * Set up blog options property.
    372          *
    373          * Passes property through 'xmlrpc_blog_options' filter.
    374          *
    375          * @since 2.6.0
    376          */
    377         function initialise_blog_option_info( ) {
    378                 global $wp_version;
    379 
    380                 $this->blog_options = array(
    381                         // Read only options
    382                         'software_name'         => array(
    383                                 'desc'                  => __( 'Software Name' ),
    384                                 'readonly'              => true,
    385                                 'value'                 => 'WordPress'
    386                         ),
    387                         'software_version'      => array(
    388                                 'desc'                  => __( 'Software Version' ),
    389                                 'readonly'              => true,
    390                                 'value'                 => $wp_version
    391                         ),
    392                         'blog_url'                      => array(
    393                                 'desc'                  => __( 'Site URL' ),
    394                                 'readonly'              => true,
    395                                 'option'                => 'siteurl'
    396                         ),
    397 
    398                         // Updatable options
    399                         'time_zone'                     => array(
    400                                 'desc'                  => __( 'Time Zone' ),
    401                                 'readonly'              => false,
    402                                 'option'                => 'gmt_offset'
    403                         ),
    404                         'blog_title'            => array(
    405                                 'desc'                  => __( 'Site Title' ),
    406                                 'readonly'              => false,
    407                                 'option'                        => 'blogname'
    408                         ),
    409                         'blog_tagline'          => array(
    410                                 'desc'                  => __( 'Site Tagline' ),
    411                                 'readonly'              => false,
    412                                 'option'                => 'blogdescription'
    413                         ),
    414                         'date_format'           => array(
    415                                 'desc'                  => __( 'Date Format' ),
    416                                 'readonly'              => false,
    417                                 'option'                => 'date_format'
    418                         ),
    419                         'time_format'           => array(
    420                                 'desc'                  => __( 'Time Format' ),
    421                                 'readonly'              => false,
    422                                 'option'                => 'time_format'
    423                         ),
    424                         'users_can_register'    => array(
    425                                 'desc'                  => __( 'Allow new users to sign up' ),
    426                                 'readonly'              => false,
    427                                 'option'                => 'users_can_register'
    428                         )
    429                 );
    430 
    431                 $this->blog_options = apply_filters( 'xmlrpc_blog_options', $this->blog_options );
    432         }
    433 
    434         /**
    435          * Retrieve the blogs of the user.
    436          *
    437          * @since 2.6.0
    438          *
    439          * @param array $args Method parameters.
    440          * @return array
    441          */
    442         function wp_getUsersBlogs( $args ) {
    443                 global $current_site;
    444                 // If this isn't on WPMU then just use blogger_getUsersBlogs
    445                 if ( !is_multisite() ) {
    446                         array_unshift( $args, 1 );
    447                         return $this->blogger_getUsersBlogs( $args );
    448                 }
    449 
    450                 $this->escape( $args );
    451 
    452                 $username = $args[0];
    453                 $password = $args[1];
    454 
    455                 if ( !$user = $this->login($username, $password) )
    456                         return $this->error;
    457 
    458 
    459                 do_action( 'xmlrpc_call', 'wp.getUsersBlogs' );
    460 
    461                 $blogs = (array) get_blogs_of_user( $user->ID );
    462                 $struct = array( );
    463 
    464                 foreach ( $blogs as $blog ) {
    465                         // Don't include blogs that aren't hosted at this site
    466                         if ( $blog->site_id != $current_site->id )
    467                                 continue;
    468 
    469                         $blog_id = $blog->userblog_id;
    470                         switch_to_blog($blog_id);
    471                         $is_admin = current_user_can('manage_options');
    472 
    473                         $struct[] = array(
    474                                 'isAdmin'               => $is_admin,
    475                                 'url'                   => get_option( 'home' ) . '/',
    476                                 'blogid'                => $blog_id,
    477                                 'blogName'              => get_option( 'blogname' ),
    478                                 'xmlrpc'                => site_url( 'xmlrpc.php' )
    479                         );
    480 
    481                         restore_current_blog( );
    482                 }
    483 
    484                 return $struct;
    485         }
    486 
    487         /**
    488          * Retrieve page.
    489          *
    490          * @since 2.2.0
    491          *
    492          * @param array $args Method parameters.
    493          * @return array
    494          */
    495         function wp_getPage($args) {
    496                 $this->escape($args);
    497 
    498                 $blog_id        = (int) $args[0];
    499                 $page_id        = (int) $args[1];
    500                 $username       = $args[2];
    501                 $password       = $args[3];
    502 
    503                 if ( !$user = $this->login($username, $password) ) {
    504                         return $this->error;
    505                 }
    506 
    507                 if ( !current_user_can( 'edit_page', $page_id ) )
    508                         return new IXR_Error( 401, __( 'Sorry, you cannot edit this page.' ) );
    509 
    510                 do_action('xmlrpc_call', 'wp.getPage');
    511 
    512                 // Lookup page info.
    513                 $page = get_page($page_id);
    514 
    515                 // If we found the page then format the data.
    516                 if ( $page->ID && ($page->post_type == "page") ) {
    517                         // Get all of the page content and link.
    518                         $full_page = get_extended($page->post_content);
    519                         $link = post_permalink($page->ID);
    520 
    521                         // Get info the page parent if there is one.
    522                         $parent_title = "";
    523                         if ( !empty($page->post_parent) ) {
    524                                 $parent = get_page($page->post_parent);
    525                                 $parent_title = $parent->post_title;
    526                         }
    527 
    528                         // Determine comment and ping settings.
    529                         $allow_comments = comments_open($page->ID) ? 1 : 0;
    530                         $allow_pings = pings_open($page->ID) ? 1 : 0;
    531 
    532                         // Format page date.
    533                         $page_date = mysql2date("Ymd\TH:i:s", $page->post_date, false);
    534                         $page_date_gmt = mysql2date("Ymd\TH:i:s", $page->post_date_gmt, false);
    535 
    536                         // For drafts use the GMT version of the date
    537                         if ( $page->post_status == 'draft' )
    538                                 $page_date_gmt = get_gmt_from_date( mysql2date( 'Y-m-d H:i:s', $page->post_date ), 'Ymd\TH:i:s' );
    539 
    540                         // Pull the categories info together.
    541                         $categories = array();
    542                         foreach ( wp_get_post_categories($page->ID) as $cat_id ) {
    543                                 $categories[] = get_cat_name($cat_id);
    544                         }
    545 
    546                         // Get the author info.
    547                         $author = get_userdata($page->post_author);
    548 
    549                         $page_template = get_post_meta( $page->ID, '_wp_page_template', true );
    550                         if ( empty( $page_template ) )
    551                                 $page_template = 'default';
    552 
    553                         $page_struct = array(
    554                                 "dateCreated"                   => new IXR_Date($page_date),
    555                                 "userid"                                => $page->post_author,
    556                                 "page_id"                               => $page->ID,
    557                                 "page_status"                   => $page->post_status,
    558                                 "description"                   => $full_page["main"],
    559                                 "title"                                 => $page->post_title,
    560                                 "link"                                  => $link,
    561                                 "permaLink"                             => $link,
    562                                 "categories"                    => $categories,
    563                                 "excerpt"                               => $page->post_excerpt,
    564                                 "text_more"                             => $full_page["extended"],
    565                                 "mt_allow_comments"             => $allow_comments,
    566                                 "mt_allow_pings"                => $allow_pings,
    567                                 "wp_slug"                               => $page->post_name,
    568                                 "wp_password"                   => $page->post_password,
    569                                 "wp_author"                             => $author->display_name,
    570                                 "wp_page_parent_id"             => $page->post_parent,
    571                                 "wp_page_parent_title"  => $parent_title,
    572                                 "wp_page_order"                 => $page->menu_order,
    573                                 "wp_author_id"                  => $author->ID,
    574                                 "wp_author_display_name"        => $author->display_name,
    575                                 "date_created_gmt"              => new IXR_Date($page_date_gmt),
    576                                 "custom_fields"                 => $this->get_custom_fields($page_id),
    577                                 "wp_page_template"              => $page_template
    578                         );
    579 
    580                         return($page_struct);
    581                 }
    582                 // If the page doesn't exist indicate that.
    583                 else {
    584                         return(new IXR_Error(404, __("Sorry, no such page.")));
    585                 }
    586         }
    587 
    588         /**
    589          * Retrieve Pages.
    590          *
    591          * @since 2.2.0
    592          *
    593          * @param array $args Method parameters.
    594          * @return array
    595          */
    596         function wp_getPages($args) {
    597                 $this->escape($args);
    598 
    599                 $blog_id        = (int) $args[0];
    600                 $username       = $args[1];
    601                 $password       = $args[2];
    602                 $num_pages      = isset($args[3]) ? (int) $args[3] : 10;
    603 
    604                 if ( !$user = $this->login($username, $password) )
    605                         return $this->error;
    606 
    607                 if ( !current_user_can( 'edit_pages' ) )
    608                         return new IXR_Error( 401, __( 'Sorry, you cannot edit pages.' ) );
    609 
    610                 do_action('xmlrpc_call', 'wp.getPages');
    611 
    612                 $pages = get_posts( array('post_type' => 'page', 'post_status' => 'any', 'numberposts' => $num_pages) );
    613                 $num_pages = count($pages);
    614 
    615                 // If we have pages, put together their info.
    616                 if ( $num_pages >= 1 ) {
    617                         $pages_struct = array();
    618 
    619                         for ( $i = 0; $i < $num_pages; $i++ ) {
    620                                 $page = wp_xmlrpc_server::wp_getPage(array(
    621                                         $blog_id, $pages[$i]->ID, $username, $password
    622                                 ));
    623                                 $pages_struct[] = $page;
    624                         }
    625 
    626                         return($pages_struct);
    627                 }
    628                 // If no pages were found return an error.
    629                 else {
    630                         return(array());
    631                 }
    632         }
    633 
    634         /**
    635          * Create new page.
    636          *
    637          * @since 2.2.0
    638          *
    639          * @param array $args Method parameters.
    640          * @return unknown
    641          */
    642         function wp_newPage($args) {
    643                 // Items not escaped here will be escaped in newPost.
    644                 $username       = $this->escape($args[1]);
    645                 $password       = $this->escape($args[2]);
    646                 $page           = $args[3];
    647                 $publish        = $args[4];
    648 
    649                 if ( !$user = $this->login($username, $password) )
    650                         return $this->error;
    651 
    652                 do_action('xmlrpc_call', 'wp.newPage');
    653 
    654                 // Make sure the user is allowed to add new pages.
    655                 if ( !current_user_can("publish_pages") )
    656                         return(new IXR_Error(401, __("Sorry, you cannot add new pages.")));
    657 
    658                 // Mark this as content for a page.
    659                 $args[3]["post_type"] = "page";
    660 
    661                 // Let mw_newPost do all of the heavy lifting.
    662                 return($this->mw_newPost($args));
    663         }
    664 
    665         /**
    666          * Delete page.
    667          *
    668          * @since 2.2.0
    669          *
    670          * @param array $args Method parameters.
    671          * @return bool True, if success.
    672          */
    673         function wp_deletePage($args) {
    674                 $this->escape($args);
    675 
    676                 $blog_id        = (int) $args[0];
    677                 $username       = $args[1];
    678                 $password       = $args[2];
    679                 $page_id        = (int) $args[3];
    680 
    681                 if ( !$user = $this->login($username, $password) )
    682                         return $this->error;
    683 
    684                 do_action('xmlrpc_call', 'wp.deletePage');
    685 
    686                 // Get the current page based on the page_id and
    687                 // make sure it is a page and not a post.
    688                 $actual_page = wp_get_single_post($page_id, ARRAY_A);
    689                 if ( !$actual_page || ($actual_page["post_type"] != "page") )
    690                         return(new IXR_Error(404, __("Sorry, no such page.")));
    691 
    692                 // Make sure the user can delete pages.
    693                 if ( !current_user_can("delete_page", $page_id) )
    694                         return(new IXR_Error(401, __("Sorry, you do not have the right to delete this page.")));
    695 
    696                 // Attempt to delete the page.
    697                 $result = wp_delete_post($page_id);
    698                 if ( !$result )
    699                         return(new IXR_Error(500, __("Failed to delete the page.")));
    700 
    701                 return(true);
    702         }
    703 
    704         /**
    705          * Edit page.
    706          *
    707          * @since 2.2.0
    708          *
    709          * @param array $args Method parameters.
    710          * @return unknown
    711          */
    712         function wp_editPage($args) {
    713                 // Items not escaped here will be escaped in editPost.
    714                 $blog_id        = (int) $args[0];
    715                 $page_id        = (int) $this->escape($args[1]);
    716                 $username       = $this->escape($args[2]);
    717                 $password       = $this->escape($args[3]);
    718                 $content        = $args[4];
    719                 $publish        = $args[5];
    720 
    721                 if ( !$user = $this->login($username, $password) )
    722                         return $this->error;
    723 
    724                 do_action('xmlrpc_call', 'wp.editPage');
    725 
    726                 // Get the page data and make sure it is a page.
    727                 $actual_page = wp_get_single_post($page_id, ARRAY_A);
    728                 if ( !$actual_page || ($actual_page["post_type"] != "page") )
    729                         return(new IXR_Error(404, __("Sorry, no such page.")));
    730 
    731                 // Make sure the user is allowed to edit pages.
    732                 if ( !current_user_can("edit_page", $page_id) )
    733                         return(new IXR_Error(401, __("Sorry, you do not have the right to edit this page.")));
    734 
    735                 // Mark this as content for a page.
    736                 $content["post_type"] = "page";
    737 
    738                 // Arrange args in the way mw_editPost understands.
    739                 $args = array(
    740                         $page_id,
    741                         $username,
    742                         $password,
    743                         $content,
    744                         $publish
    745                 );
    746 
    747                 // Let mw_editPost do all of the heavy lifting.
    748                 return($this->mw_editPost($args));
    749         }
    750 
    751         /**
    752          * Retrieve page list.
    753          *
    754          * @since 2.2.0
    755          *
    756          * @param array $args Method parameters.
    757          * @return unknown
    758          */
    759         function wp_getPageList($args) {
    760                 global $wpdb;
    761 
    762                 $this->escape($args);
    763 
    764                 $blog_id                                = (int) $args[0];
    765                 $username                               = $args[1];
    766                 $password                               = $args[2];
    767 
    768                 if ( !$user = $this->login($username, $password) )
    769                         return $this->error;
    770 
    771                 if ( !current_user_can( 'edit_pages' ) )
    772                         return new IXR_Error( 401, __( 'Sorry, you cannot edit pages.' ) );
    773 
    774                 do_action('xmlrpc_call', 'wp.getPageList');
    775 
    776                 // Get list of pages ids and titles
    777                 $page_list = $wpdb->get_results("
    778                         SELECT ID page_id,
    779                                 post_title page_title,
    780                                 post_parent page_parent_id,
    781                                 post_date_gmt,
    782                                 post_date,
    783                                 post_status
    784                         FROM {$wpdb->posts}
    785                         WHERE post_type = 'page'
    786                         ORDER BY ID
    787                 ");
    788 
    789                 // The date needs to be formated properly.
    790                 $num_pages = count($page_list);
    791                 for ( $i = 0; $i < $num_pages; $i++ ) {
    792                         $post_date = mysql2date("Ymd\TH:i:s", $page_list[$i]->post_date, false);
    793                         $post_date_gmt = mysql2date("Ymd\TH:i:s", $page_list[$i]->post_date_gmt, false);
    794 
    795                         $page_list[$i]->dateCreated = new IXR_Date($post_date);
    796                         $page_list[$i]->date_created_gmt = new IXR_Date($post_date_gmt);
    797 
    798                         // For drafts use the GMT version of the date
    799                         if ( $page_list[$i]->post_status == 'draft' ) {
    800                                 $page_list[$i]->date_created_gmt = get_gmt_from_date( mysql2date( 'Y-m-d H:i:s', $page_list[$i]->post_date ), 'Ymd\TH:i:s' );
    801                                 $page_list[$i]->date_created_gmt = new IXR_Date( $page_list[$i]->date_created_gmt );
    802                         }
    803 
    804                         unset($page_list[$i]->post_date_gmt);
    805                         unset($page_list[$i]->post_date);
    806                         unset($page_list[$i]->post_status);
    807                 }
    808 
    809                 return($page_list);
    810         }
    811 
    812         /**
    813          * Retrieve authors list.
    814          *
    815          * @since 2.2.0
    816          *
    817          * @param array $args Method parameters.
    818          * @return array
    819          */
    820         function wp_getAuthors($args) {
    821 
    822                 $this->escape($args);
    823 
    824                 $blog_id        = (int) $args[0];
    825                 $username       = $args[1];
    826                 $password       = $args[2];
    827 
    828                 if ( !$user = $this->login($username, $password) )
    829                         return $this->error;
    830 
    831                 if ( !current_user_can("edit_posts") )
    832                         return(new IXR_Error(401, __("Sorry, you cannot edit posts on this site.")));
    833 
    834                 do_action('xmlrpc_call', 'wp.getAuthors');
    835 
    836                 $authors = array();
    837                 foreach ( get_users() as $user_id => $user_object ) {
    838                         $authors[] = array(
    839                                 "user_id"       => $user_id,
    840                                 "user_login"    => $user_object->user_login,
    841                                 "display_name"  => $user_object->display_name
    842                         );
    843                 }
    844 
    845                 return $authors;
    846         }
    847 
    848         /**
    849          * Get list of all tags
    850          *
    851          * @since 2.7
    852          *
    853          * @param array $args Method parameters.
    854          * @return array
    855          */
    856         function wp_getTags( $args ) {
    857                 $this->escape( $args );
    858 
    859                 $blog_id                = (int) $args[0];
    860                 $username               = $args[1];
    861                 $password               = $args[2];
    862 
    863                 if ( !$user = $this->login($username, $password) )
    864                         return $this->error;
    865 
    866                 if ( !current_user_can( 'edit_posts' ) )
    867                         return new IXR_Error( 401, __( 'Sorry, you must be able to edit posts on this site in order to view tags.' ) );
    868 
    869                 do_action( 'xmlrpc_call', 'wp.getKeywords' );
    870 
    871                 $tags = array( );
    872 
    873                 if ( $all_tags = get_tags() ) {
    874                         foreach( (array) $all_tags as $tag ) {
    875                                 $struct['tag_id']                       = $tag->term_id;
    876                                 $struct['name']                         = $tag->name;
    877                                 $struct['count']                        = $tag->count;
    878                                 $struct['slug']                         = $tag->slug;
    879                                 $struct['html_url']                     = esc_html( get_tag_link( $tag->term_id ) );
    880                                 $struct['rss_url']                      = esc_html( get_tag_feed_link( $tag->term_id ) );
    881 
    882                                 $tags[] = $struct;
    883                         }
    884                 }
    885 
    886                 return $tags;
    887         }
    888 
    889         /**
    890          * Create new category.
    891          *
    892          * @since 2.2.0
    893          *
    894          * @param array $args Method parameters.
    895          * @return int Category ID.
    896          */
    897         function wp_newCategory($args) {
    898                 $this->escape($args);
    899 
    900                 $blog_id                                = (int) $args[0];
    901                 $username                               = $args[1];
    902                 $password                               = $args[2];
    903                 $category                               = $args[3];
    904 
    905                 if ( !$user = $this->login($username, $password) )
    906                         return $this->error;
    907 
    908                 do_action('xmlrpc_call', 'wp.newCategory');
    909 
    910                 // Make sure the user is allowed to add a category.
    911                 if ( !current_user_can("manage_categories") )
    912                         return(new IXR_Error(401, __("Sorry, you do not have the right to add a category.")));
    913 
    914                 // If no slug was provided make it empty so that
    915                 // WordPress will generate one.
    916                 if ( empty($category["slug"]) )
    917                         $category["slug"] = "";
    918 
    919                 // If no parent_id was provided make it empty
    920                 // so that it will be a top level page (no parent).
    921                 if ( !isset($category["parent_id"]) )
    922                         $category["parent_id"] = "";
    923 
    924                 // If no description was provided make it empty.
    925                 if ( empty($category["description"]) )
    926                         $category["description"] = "";
    927 
    928                 $new_category = array(
    929                         "cat_name"                              => $category["name"],
    930                         "category_nicename"             => $category["slug"],
    931                         "category_parent"               => $category["parent_id"],
    932                         "category_description"  => $category["description"]
    933                 );
    934 
    935                 $cat_id = wp_insert_category($new_category, true);
    936                 if ( is_wp_error( $cat_id ) ) {
    937                         if ( 'term_exists' == $cat_id->get_error_code() )
    938                                 return (int) $cat_id->get_error_data();
    939                         else
    940                                 return(new IXR_Error(500, __("Sorry, the new category failed.")));
    941                 } elseif ( ! $cat_id ) {
    942                         return(new IXR_Error(500, __("Sorry, the new category failed.")));
    943                 }
    944 
    945                 return($cat_id);
    946         }
    947 
    948         /**
    949          * Remove category.
    950          *
    951          * @since 2.5.0
    952          *
    953          * @param array $args Method parameters.
    954          * @return mixed See {@link wp_delete_category()} for return info.
    955          */
    956         function wp_deleteCategory($args) {
    957                 $this->escape($args);
    958 
    959                 $blog_id                = (int) $args[0];
    960                 $username               = $args[1];
    961                 $password               = $args[2];
    962                 $category_id    = (int) $args[3];
    963 
    964                 if ( !$user = $this->login($username, $password) )
    965                         return $this->error;
    966 
    967                 do_action('xmlrpc_call', 'wp.deleteCategory');
    968 
    969                 if ( !current_user_can("manage_categories") )
    970                         return new IXR_Error( 401, __( "Sorry, you do not have the right to delete a category." ) );
    971 
    972                 return wp_delete_category( $category_id );
    973         }
    974 
    975         /**
    976          * Retrieve category list.
    977          *
    978          * @since 2.2.0
    979          *
    980          * @param array $args Method parameters.
    981          * @return array
    982          */
    983         function wp_suggestCategories($args) {
    984                 $this->escape($args);
    985 
    986                 $blog_id                                = (int) $args[0];
    987                 $username                               = $args[1];
    988                 $password                               = $args[2];
    989                 $category                               = $args[3];
    990                 $max_results                    = (int) $args[4];
    991 
    992                 if ( !$user = $this->login($username, $password) )
    993                         return $this->error;
    994 
    995                 if ( !current_user_can( 'edit_posts' ) )
    996                         return new IXR_Error( 401, __( 'Sorry, you must be able to edit posts to this site in order to view categories.' ) );
    997 
    998                 do_action('xmlrpc_call', 'wp.suggestCategories');
    999 
    1000                 $category_suggestions = array();
    1001                 $args = array('get' => 'all', 'number' => $max_results, 'name__like' => $category);
    1002                 foreach ( (array) get_categories($args) as $cat ) {
    1003                         $category_suggestions[] = array(
    1004                                 "category_id"   => $cat->cat_ID,
    1005                                 "category_name" => $cat->cat_name
    1006                         );
    1007                 }
    1008 
    1009                 return($category_suggestions);
    1010         }
    1011 
    1012         /**
    1013          * Retrieve comment.
    1014          *
    1015          * @since 2.7.0
    1016          *
    1017          * @param array $args Method parameters.
    1018          * @return array
    1019          */
    1020         function wp_getComment($args) {
    1021                 $this->escape($args);
    1022 
    1023                 $blog_id        = (int) $args[0];
    1024                 $username       = $args[1];
    1025                 $password       = $args[2];
    1026                 $comment_id     = (int) $args[3];
    1027 
    1028                 if ( !$user = $this->login($username, $password) )
    1029                         return $this->error;
    1030 
    1031                 if ( !current_user_can( 'moderate_comments' ) )
    1032                         return new IXR_Error( 403, __( 'You are not allowed to moderate comments on this site.' ) );
    1033 
    1034                 do_action('xmlrpc_call', 'wp.getComment');
    1035 
    1036                 if ( ! $comment = get_comment($comment_id) )
    1037                         return new IXR_Error( 404, __( 'Invalid comment ID.' ) );
    1038 
    1039                 // Format page date.
    1040                 $comment_date = mysql2date("Ymd\TH:i:s", $comment->comment_date, false);
    1041                 $comment_date_gmt = mysql2date("Ymd\TH:i:s", $comment->comment_date_gmt, false);
    1042 
    1043                 if ( '0' == $comment->comment_approved )
    1044                         $comment_status = 'hold';
    1045                 else if ( 'spam' == $comment->comment_approved )
    1046                         $comment_status = 'spam';
    1047                 else if ( '1' == $comment->comment_approved )
    1048                         $comment_status = 'approve';
    1049                 else
    1050                         $comment_status = $comment->comment_approved;
    1051 
    1052                 $link = get_comment_link($comment);
    1053 
    1054                 $comment_struct = array(
    1055                         "date_created_gmt"              => new IXR_Date($comment_date_gmt),
    1056                         "user_id"                               => $comment->user_id,
    1057                         "comment_id"                    => $comment->comment_ID,
    1058                         "parent"                                => $comment->comment_parent,
    1059                         "status"                                => $comment_status,
    1060                         "content"                               => $comment->comment_content,
    1061                         "link"                                  => $link,
    1062                         "post_id"                               => $comment->comment_post_ID,
    1063                         "post_title"                    => get_the_title($comment->comment_post_ID),
    1064                         "author"                                => $comment->comment_author,
    1065                         "author_url"                    => $comment->comment_author_url,
    1066                         "author_email"                  => $comment->comment_author_email,
    1067                         "author_ip"                             => $comment->comment_author_IP,
    1068                         "type"                                  => $comment->comment_type,
    1069                 );
    1070 
    1071                 return $comment_struct;
    1072         }
    1073 
    1074         /**
    1075          * Retrieve comments.
    1076          *
    1077          * @since 2.7.0
    1078          *
    1079          * @param array $args Method parameters.
    1080          * @return array
    1081          */
    1082         function wp_getComments($args) {
    1083                 $raw_args = $args;
    1084                 $this->escape($args);
    1085 
    1086                 $blog_id        = (int) $args[0];
    1087                 $username       = $args[1];
    1088                 $password       = $args[2];
    1089                 $struct         = $args[3];
    1090 
    1091                 if ( !$user = $this->login($username, $password) )
    1092                         return $this->error;
    1093 
    1094                 if ( !current_user_can( 'moderate_comments' ) )
    1095                         return new IXR_Error( 401, __( 'Sorry, you cannot edit comments.' ) );
    1096 
    1097                 do_action('xmlrpc_call', 'wp.getComments');
    1098 
    1099                 if ( isset($struct['status']) )
    1100                         $status = $struct['status'];
    1101                 else
    1102                         $status = '';
    1103 
    1104                 $post_id = '';
    1105                 if ( isset($struct['post_id']) )
    1106                         $post_id = absint($struct['post_id']);
    1107 
    1108                 $offset = 0;
    1109                 if ( isset($struct['offset']) )
    1110                         $offset = absint($struct['offset']);
    1111 
    1112                 $number = 10;
    1113                 if ( isset($struct['number']) )
    1114                         $number = absint($struct['number']);
    1115 
    1116                 $comments = get_comments( array('status' => $status, 'post_id' => $post_id, 'offset' => $offset, 'number' => $number ) );
    1117                 $num_comments = count($comments);
    1118 
    1119                 if ( ! $num_comments )
    1120                         return array();
    1121 
    1122                 $comments_struct = array();
    1123 
    1124                 for ( $i = 0; $i < $num_comments; $i++ ) {
    1125                         $comment = wp_xmlrpc_server::wp_getComment(array(
    1126                                 $raw_args[0], $raw_args[1], $raw_args[2], $comments[$i]->comment_ID,
    1127                         ));
    1128                         $comments_struct[] = $comment;
    1129                 }
    1130 
    1131                 return $comments_struct;
    1132         }
    1133 
    1134         /**
    1135          * Remove comment.
    1136          *
    1137          * @since 2.7.0
    1138          *
    1139          * @param array $args Method parameters.
    1140          * @return mixed {@link wp_delete_comment()}
    1141          */
    1142         function wp_deleteComment($args) {
    1143                 $this->escape($args);
    1144 
    1145                 $blog_id        = (int) $args[0];
    1146                 $username       = $args[1];
    1147                 $password       = $args[2];
    1148                 $comment_ID     = (int) $args[3];
    1149 
    1150                 if ( !$user = $this->login($username, $password) )
    1151                         return $this->error;
    1152 
    1153                 if ( !current_user_can( 'moderate_comments' ) )
    1154                         return new IXR_Error( 403, __( 'You are not allowed to moderate comments on this site.' ) );
    1155 
    1156                 do_action('xmlrpc_call', 'wp.deleteComment');
    1157 
    1158                 if ( ! get_comment($comment_ID) )
    1159                         return new IXR_Error( 404, __( 'Invalid comment ID.' ) );
    1160 
    1161                 return wp_delete_comment($comment_ID);
    1162         }
    1163 
    1164         /**
    1165          * Edit comment.
    1166          *
    1167          * @since 2.7.0
    1168          *
    1169          * @param array $args Method parameters.
    1170          * @return bool True, on success.
    1171          */
    1172         function wp_editComment($args) {
    1173                 $this->escape($args);
    1174 
    1175                 $blog_id        = (int) $args[0];
    1176                 $username       = $args[1];
    1177                 $password       = $args[2];
    1178                 $comment_ID     = (int) $args[3];
    1179                 $content_struct = $args[4];
    1180 
    1181                 if ( !$user = $this->login($username, $password) )
    1182                         return $this->error;
    1183 
    1184                 if ( !current_user_can( 'moderate_comments' ) )
    1185                         return new IXR_Error( 403, __( 'You are not allowed to moderate comments on this site.' ) );
    1186 
    1187                 do_action('xmlrpc_call', 'wp.editComment');
    1188 
    1189                 if ( ! get_comment($comment_ID) )
    1190                         return new IXR_Error( 404, __( 'Invalid comment ID.' ) );
    1191 
    1192                 if ( isset($content_struct['status']) ) {
    1193                         $statuses = get_comment_statuses();
    1194                         $statuses = array_keys($statuses);
    1195 
    1196                         if ( ! in_array($content_struct['status'], $statuses) )
    1197                                 return new IXR_Error( 401, __( 'Invalid comment status.' ) );
    1198                         $comment_approved = $content_struct['status'];
    1199                 }
    1200 
    1201                 // Do some timestamp voodoo
    1202                 if ( !empty( $content_struct['date_created_gmt'] ) ) {
    1203                         $dateCreated = str_replace( 'Z', '', $content_struct['date_created_gmt']->getIso() ) . 'Z'; // We know this is supposed to be GMT, so we're going to slap that Z on there by force
    1204                         $comment_date = get_date_from_gmt(iso8601_to_datetime($dateCreated));
    1205                         $comment_date_gmt = iso8601_to_datetime($dateCreated, GMT);
    1206                 }
    1207 
    1208                 if ( isset($content_struct['content']) )
    1209                         $comment_content = $content_struct['content'];
    1210 
    1211                 if ( isset($content_struct['author']) )
    1212                         $comment_author = $content_struct['author'];
    1213 
    1214                 if ( isset($content_struct['author_url']) )
    1215                         $comment_author_url = $content_struct['author_url'];
    1216 
    1217                 if ( isset($content_struct['author_email']) )
    1218                         $comment_author_email = $content_struct['author_email'];
    1219 
    1220                 // We've got all the data -- post it:
    1221                 $comment = compact('comment_ID', 'comment_content', 'comment_approved', 'comment_date', 'comment_date_gmt', 'comment_author', 'comment_author_email', 'comment_author_url');
    1222 
    1223                 $result = wp_update_comment($comment);
    1224                 if ( is_wp_error( $result ) )
    1225                         return new IXR_Error(500, $result->get_error_message());
    1226 
    1227                 if ( !$result )
    1228                         return new IXR_Error(500, __('Sorry, the comment could not be edited. Something wrong happened.'));
    1229 
    1230                 return true;
    1231         }
    1232 
    1233         /**
    1234          * Create new comment.
    1235          *
    1236          * @since 2.7.0
    1237          *
    1238          * @param array $args Method parameters.
    1239          * @return mixed {@link wp_new_comment()}
    1240          */
    1241         function wp_newComment($args) {
    1242                 global $wpdb;
    1243 
    1244                 $this->escape($args);
    1245 
    1246                 $blog_id        = (int) $args[0];
    1247                 $username       = $args[1];
    1248                 $password       = $args[2];
    1249                 $post           = $args[3];
    1250                 $content_struct = $args[4];
    1251 
    1252                 $allow_anon = apply_filters('xmlrpc_allow_anonymous_comments', false);
    1253 
    1254                 $user = $this->login($username, $password);
    1255 
    1256                 if ( !$user ) {
    1257                         $logged_in = false;
    1258                         if ( $allow_anon && get_option('comment_registration') )
    1259                                 return new IXR_Error( 403, __( 'You must be registered to comment' ) );
    1260                         else if ( !$allow_anon )
    1261                                 return $this->error;
    1262                 } else {
    1263                         $logged_in = true;
    1264                 }
    1265 
    1266                 if ( is_numeric($post) )
    1267                         $post_id = absint($post);
    1268                 else
    1269                         $post_id = url_to_postid($post);
    1270 
    1271                 if ( ! $post_id )
    1272                         return new IXR_Error( 404, __( 'Invalid post ID.' ) );
    1273 
    1274                 if ( ! get_post($post_id) )
    1275                         return new IXR_Error( 404, __( 'Invalid post ID.' ) );
    1276 
    1277                 $comment['comment_post_ID'] = $post_id;
    1278 
    1279                 if ( $logged_in ) {
    1280                         $comment['comment_author'] = $wpdb->escape( $user->display_name );
    1281                         $comment['comment_author_email'] = $wpdb->escape( $user->user_email );
    1282                         $comment['comment_author_url'] = $wpdb->escape( $user->user_url );
    1283                         $comment['user_ID'] = $user->ID;
    1284                 } else {
    1285                         $comment['comment_author'] = '';
    1286                         if ( isset($content_struct['author']) )
    1287                                 $comment['comment_author'] = $content_struct['author'];
    1288 
    1289                         $comment['comment_author_email'] = '';
    1290                         if ( isset($content_struct['author_email']) )
    1291                                 $comment['comment_author_email'] = $content_struct['author_email'];
    1292 
    1293                         $comment['comment_author_url'] = '';
    1294                         if ( isset($content_struct['author_url']) )
    1295                                 $comment['comment_author_url'] = $content_struct['author_url'];
    1296 
    1297                         $comment['user_ID'] = 0;
    1298 
    1299                         if ( get_option('require_name_email') ) {
    1300                                 if ( 6 > strlen($comment['comment_author_email']) || '' == $comment['comment_author'] )
    1301                                         return new IXR_Error( 403, __( 'Comment author name and email are required' ) );
    1302                                 elseif ( !is_email($comment['comment_author_email']) )
    1303                                         return new IXR_Error( 403, __( 'A valid email address is required' ) );
    1304                         }
    1305                 }
    1306 
    1307                 $comment['comment_parent'] = isset($content_struct['comment_parent']) ? absint($content_struct['comment_parent']) : 0;
    1308 
    1309                 $comment['comment_content'] = $content_struct['content'];
    1310 
    1311                 do_action('xmlrpc_call', 'wp.newComment');
    1312 
    1313                 return wp_new_comment($comment);
    1314         }
    1315 
    1316         /**
    1317          * Retrieve all of the comment status.
    1318          *
    1319          * @since 2.7.0
    1320          *
    1321          * @param array $args Method parameters.
    1322          * @return array
    1323          */
    1324         function wp_getCommentStatusList($args) {
    1325                 $this->escape( $args );
    1326 
    1327                 $blog_id        = (int) $args[0];
    1328                 $username       = $args[1];
    1329                 $password       = $args[2];
    1330 
    1331                 if ( !$user = $this->login($username, $password) )
    1332                         return $this->error;
    1333 
    1334                 if ( !current_user_can( 'moderate_comments' ) )
    1335                         return new IXR_Error( 403, __( 'You are not allowed access to details about this site.' ) );
    1336 
    1337                 do_action('xmlrpc_call', 'wp.getCommentStatusList');
    1338 
    1339                 return get_comment_statuses( );
    1340         }
    1341 
    1342         /**
    1343          * Retrieve comment count.
    1344          *
    1345          * @since 2.5.0
    1346          *
    1347          * @param array $args Method parameters.
    1348          * @return array
    1349          */
    1350         function wp_getCommentCount( $args ) {
    1351                 $this->escape($args);
    1352 
    1353                 $blog_id        = (int) $args[0];
    1354                 $username       = $args[1];
    1355                 $password       = $args[2];
    1356                 $post_id        = (int) $args[3];
    1357 
    1358                 if ( !$user = $this->login($username, $password) )
    1359                         return $this->error;
    1360 
    1361                 if ( !current_user_can( 'edit_posts' ) )
    1362                         return new IXR_Error( 403, __( 'You are not allowed access to details about comments.' ) );
    1363 
    1364                 do_action('xmlrpc_call', 'wp.getCommentCount');
    1365 
    1366                 $count = wp_count_comments( $post_id );
    1367                 return array(
    1368                         "approved" => $count->approved,
    1369                         "awaiting_moderation" => $count->moderated,
    1370                         "spam" => $count->spam,
    1371                         "total_comments" => $count->total_comments
    1372                 );
    1373         }
    1374 
    1375         /**
    1376          * Retrieve post statuses.
    1377          *
    1378          * @since 2.5.0
    1379          *
    1380          * @param array $args Method parameters.
    1381          * @return array
    1382          */
    1383         function wp_getPostStatusList( $args ) {
    1384                 $this->escape( $args );
    1385 
    1386                 $blog_id        = (int) $args[0];
    1387                 $username       = $args[1];
    1388                 $password       = $args[2];
    1389 
    1390                 if ( !$user = $this->login($username, $password) )
    1391                         return $this->error;
    1392 
    1393                 if ( !current_user_can( 'edit_posts' ) )
    1394                         return new IXR_Error( 403, __( 'You are not allowed access to details about this site.' ) );
    1395 
    1396                 do_action('xmlrpc_call', 'wp.getPostStatusList');
    1397 
    1398                 return get_post_statuses( );
    1399         }
    1400 
    1401         /**
    1402          * Retrieve page statuses.
    1403          *
    1404          * @since 2.5.0
    1405          *
    1406          * @param array $args Method parameters.
    1407          * @return array
    1408          */
    1409         function wp_getPageStatusList( $args ) {
    1410                 $this->escape( $args );
    1411 
    1412                 $blog_id        = (int) $args[0];
    1413                 $username       = $args[1];
    1414                 $password       = $args[2];
    1415 
    1416                 if ( !$user = $this->login($username, $password) )
    1417                         return $this->error;
    1418 
    1419                 if ( !current_user_can( 'edit_posts' ) )
    1420                         return new IXR_Error( 403, __( 'You are not allowed access to details about this site.' ) );
    1421 
    1422                 do_action('xmlrpc_call', 'wp.getPageStatusList');
    1423 
    1424                 return get_page_statuses( );
    1425         }
    1426 
    1427         /**
    1428          * Retrieve page templates.
    1429          *
    1430          * @since 2.6.0
    1431          *
    1432          * @param array $args Method parameters.
    1433          * @return array
    1434          */
    1435         function wp_getPageTemplates( $args ) {
    1436                 $this->escape( $args );
    1437 
    1438                 $blog_id        = (int) $args[0];
    1439                 $username       = $args[1];
    1440                 $password       = $args[2];
    1441 
    1442                 if ( !$user = $this->login($username, $password) )
    1443                         return $this->error;
    1444 
    1445                 if ( !current_user_can( 'edit_pages' ) )
    1446                         return new IXR_Error( 403, __( 'You are not allowed access to details about this site.' ) );
    1447 
    1448                 $templates = get_page_templates( );
    1449                 $templates['Default'] = 'default';
    1450 
    1451                 return $templates;
    1452         }
    1453 
    1454         /**
    1455          * Retrieve blog options.
    1456          *
    1457          * @since 2.6.0
    1458          *
    1459          * @param array $args Method parameters.
    1460          * @return array
    1461          */
    1462         function wp_getOptions( $args ) {
    1463                 $this->escape( $args );
    1464 
    1465                 $blog_id        = (int) $args[0];
    1466                 $username       = $args[1];
    1467                 $password       = $args[2];
    1468                 $options        = (array) $args[3];
    1469 
    1470                 if ( !$user = $this->login($username, $password) )
    1471                         return $this->error;
    1472 
    1473                 // If no specific options where asked for, return all of them
    1474                 if ( count( $options ) == 0 )
    1475                         $options = array_keys($this->blog_options);
    1476 
    1477                 return $this->_getOptions($options);
    1478         }
    1479 
    1480         /**
    1481          * Retrieve blog options value from list.
    1482          *
    1483          * @since 2.6.0
    1484          *
    1485          * @param array $options Options to retrieve.
    1486          * @return array
    1487          */
    1488         function _getOptions($options) {
    1489                 $data = array( );
    1490                 foreach ( $options as $option ) {
    1491                         if ( array_key_exists( $option, $this->blog_options ) ) {
    1492                                 $data[$option] = $this->blog_options[$option];
    1493                                 //Is the value static or dynamic?
    1494                                 if ( isset( $data[$option]['option'] ) ) {
    1495                                         $data[$option]['value'] = get_option( $data[$option]['option'] );
    1496                                         unset($data[$option]['option']);
    1497                                 }
    1498                         }
    1499                 }
    1500 
    1501                 return $data;
    1502         }
    1503 
    1504         /**
    1505          * Update blog options.
    1506          *
    1507          * @since 2.6.0
    1508          *
    1509          * @param array $args Method parameters.
    1510          * @return unknown
    1511          */
    1512         function wp_setOptions( $args ) {
    1513                 $this->escape( $args );
    1514 
    1515                 $blog_id        = (int) $args[0];
    1516                 $username       = $args[1];
    1517                 $password       = $args[2];
    1518                 $options        = (array) $args[3];
    1519 
    1520                 if ( !$user = $this->login($username, $password) )
    1521                         return $this->error;
    1522 
    1523                 if ( !current_user_can( 'manage_options' ) )
    1524                         return new IXR_Error( 403, __( 'You are not allowed to update options.' ) );
    1525 
    1526                 foreach ( $options as $o_name => $o_value ) {
    1527                         $option_names[] = $o_name;
    1528                         if ( !array_key_exists( $o_name, $this->blog_options ) )
    1529                                 continue;
    1530 
    1531                         if ( $this->blog_options[$o_name]['readonly'] == true )
    1532                                 continue;
    1533 
    1534                         update_option( $this->blog_options[$o_name]['option'], $o_value );
    1535                 }
    1536 
    1537                 //Now return the updated values
    1538                 return $this->_getOptions($option_names);
    1539         }
    1540 
    1541         /* Blogger API functions.
    1542          * specs on http://plant.blogger.com/api and http://groups.yahoo.com/group/bloggerDev/
    1543          */
    1544 
    1545         /**
    1546          * Retrieve blogs that user owns.
    1547          *
    1548          * Will make more sense once we support multiple blogs.
    1549          *
    1550          * @since 1.5.0
    1551          *
    1552          * @param array $args Method parameters.
    1553          * @return array
    1554          */
    1555         function blogger_getUsersBlogs($args) {
    1556                 if ( is_multisite() )
    1557                         return $this->_multisite_getUsersBlogs($args);
    1558 
    1559                 $this->escape($args);
    1560 
    1561                 $username = $args[1];
    1562                 $password  = $args[2];
    1563 
    1564                 if ( !$user = $this->login($username, $password) )
    1565                         return $this->error;
    1566 
    1567                 do_action('xmlrpc_call', 'blogger.getUsersBlogs');
    1568 
    1569                 $is_admin = current_user_can('manage_options');
    1570 
    1571                 $struct = array(
    1572                         'isAdmin'  => $is_admin,
    1573                         'url'      => get_option('home') . '/',
    1574                         'blogid'   => '1',
    1575                         'blogName' => get_option('blogname'),
    1576                         'xmlrpc'   => site_url( 'xmlrpc.php' )
    1577                 );
    1578 
    1579                 return array($struct);
    1580         }
    1581 
    1582         /**
    1583          * Private function for retrieving a users blogs for multisite setups
    1584          *
    1585          * @access protected
    1586          */
    1587         function _multisite_getUsersBlogs($args) {
    1588                 global $current_blog;
    1589                 $domain = $current_blog->domain;
    1590                 $path = $current_blog->path . 'xmlrpc.php';
    1591                 $protocol = is_ssl() ? 'https' : 'http';
    1592 
    1593                 $rpc = new IXR_Client("$protocol://{$domain}{$path}");
    1594                 $rpc->query('wp.getUsersBlogs', $args[1], $args[2]);
    1595                 $blogs = $rpc->getResponse();
    1596 
    1597                 if ( isset($blogs['faultCode']) )
    1598                         return new IXR_Error($blogs['faultCode'], $blogs['faultString']);
    1599 
    1600                 if ( $_SERVER['HTTP_HOST'] == $domain && $_SERVER['REQUEST_URI'] == $path ) {
    1601                         return $blogs;
    1602                 } else {
    1603                         foreach ( (array) $blogs as $blog ) {
    1604                                 if ( strpos($blog['url'], $_SERVER['HTTP_HOST']) )
    1605                                         return array($blog);
    1606                         }
    1607                         return array();
    1608                 }
    1609         }
    1610 
    1611         /**
    1612          * Retrieve user's data.
    1613          *
    1614          * Gives your client some info about you, so you don't have to.
    1615          *
    1616          * @since 1.5.0
    1617          *
    1618          * @param array $args Method parameters.
    1619          * @return array
    1620          */
    1621         function blogger_getUserInfo($args) {
    1622 
    1623                 $this->escape($args);
    1624 
    1625                 $username = $args[1];
    1626                 $password  = $args[2];
    1627 
    1628                 if ( !$user = $this->login($username, $password) )
    1629                         return $this->error;
    1630 
    1631                 if ( !current_user_can( 'edit_posts' ) )
    1632                         return new IXR_Error( 401, __( 'Sorry, you do not have access to user data on this site.' ) );
    1633 
    1634                 do_action('xmlrpc_call', 'blogger.getUserInfo');
    1635 
    1636                 $struct = array(
    1637                         'nickname'  => $user->nickname,
    1638                         'userid'    => $user->ID,
    1639                         'url'       => $user->user_url,
    1640                         'lastname'  => $user->last_name,
    1641                         'firstname' => $user->first_name
    1642                 );
    1643 
    1644                 return $struct;
    1645         }
    1646 
    1647         /**
    1648          * Retrieve post.
    1649          *
    1650          * @since 1.5.0
    1651          *
    1652          * @param array $args Method parameters.
    1653          * @return array
    1654          */
    1655         function blogger_getPost($args) {
    1656 
    1657                 $this->escape($args);
    1658 
    1659                 $post_ID    = (int) $args[1];
    1660                 $username = $args[2];
    1661                 $password  = $args[3];
    1662 
    1663                 if ( !$user = $this->login($username, $password) )
    1664                         return $this->error;
    1665 
    1666                 if ( !current_user_can( 'edit_post', $post_ID ) )
    1667                         return new IXR_Error( 401, __( 'Sorry, you cannot edit this post.' ) );
    1668 
    1669                 do_action('xmlrpc_call', 'blogger.getPost');
    1670 
    1671                 $post_data = wp_get_single_post($post_ID, ARRAY_A);
    1672 
    1673                 $categories = implode(',', wp_get_post_categories($post_ID));
    1674 
    1675                 $content  = '<title>'.stripslashes($post_data['post_title']).'</title>';
    1676                 $content .= '<category>'.$categories.'</category>';
    1677                 $content .= stripslashes($post_data['post_content']);
    1678 
    1679                 $struct = array(
    1680                         'userid'    => $post_data['post_author'],
    1681                         'dateCreated' => new IXR_Date(mysql2date('Ymd\TH:i:s', $post_data['post_date'], false)),
    1682                         'content'     => $content,
    1683                         'postid'  => $post_data['ID']
    1684                 );
    1685 
    1686                 return $struct;
    1687         }
    1688 
    1689         /**
    1690          * Retrieve list of recent posts.
    1691          *
    1692          * @since 1.5.0
    1693          *
    1694          * @param array $args Method parameters.
    1695          * @return array
    1696          */
    1697         function blogger_getRecentPosts($args) {
    1698 
    1699                 $this->escape($args);
    1700 
    1701                 $blog_ID    = (int) $args[1]; /* though we don't use it yet */
    1702                 $username = $args[2];
    1703                 $password  = $args[3];
    1704                 $num_posts  = $args[4];
    1705 
    1706                 if ( !$user = $this->login($username, $password) )
    1707                         return $this->error;
    1708 
    1709                 do_action('xmlrpc_call', 'blogger.getRecentPosts');
    1710 
    1711                 $posts_list = wp_get_recent_posts($num_posts);
    1712 
    1713                 if ( !$posts_list ) {
    1714                         $this->error = new IXR_Error(500, __('Either there are no posts, or something went wrong.'));
    1715                         return $this->error;
    1716                 }
    1717 
    1718                 foreach ($posts_list as $entry) {
    1719                         if ( !current_user_can( 'edit_post', $entry['ID'] ) )
    1720                                 continue;
    1721 
    1722                         $post_date = mysql2date('Ymd\TH:i:s', $entry['post_date'], false);
    1723                         $categories = implode(',', wp_get_post_categories($entry['ID']));
    1724 
    1725                         $content  = '<title>'.stripslashes($entry['post_title']).'</title>';
    1726                         $content .= '<category>'.$categories.'</category>';
    1727                         $content .= stripslashes($entry['post_content']);
    1728 
    1729                         $struct[] = array(
    1730                                 'userid' => $entry['post_author'],
    1731                                 'dateCreated' => new IXR_Date($post_date),
    1732                                 'content' => $content,
    1733                                 'postid' => $entry['ID'],
    1734                         );
    1735 
    1736                 }
    1737 
    1738                 $recent_posts = array();
    1739                 for ( $j=0; $j<count($struct); $j++ ) {
    1740                         array_push($recent_posts, $struct[$j]);
    1741                 }
    1742 
    1743                 return $recent_posts;
    1744         }
    1745 
    1746         /**
    1747          * Retrieve blog_filename content.
    1748          *
    1749          * @since 1.5.0
    1750          *
    1751          * @param array $args Method parameters.
    1752          * @return string
    1753          */
    1754         function blogger_getTemplate($args) {
    1755 
    1756                 $this->escape($args);
    1757 
    1758                 $blog_ID    = (int) $args[1];
    1759                 $username = $args[2];
    1760                 $password  = $args[3];
    1761                 $template   = $args[4]; /* could be 'main' or 'archiveIndex', but we don't use it */
    1762 
    1763                 if ( !$user = $this->login($username, $password) )
    1764                         return $this->error;
    1765 
    1766                 do_action('xmlrpc_call', 'blogger.getTemplate');
    1767 
    1768                 if ( !current_user_can('edit_themes') )
    1769                         return new IXR_Error(401, __('Sorry, this user can not edit the template.'));
    1770 
    1771                 /* warning: here we make the assumption that the blog's URL is on the same server */
    1772                 $filename = get_option('home') . '/';
    1773                 $filename = preg_replace('#https?://.+?/#', $_SERVER['DOCUMENT_ROOT'].'/', $filename);
    1774 
    1775                 $f = fopen($filename, 'r');
    1776                 $content = fread($f, filesize($filename));
    1777                 fclose($f);
    1778 
    1779                 /* so it is actually editable with a windows/mac client */
    1780                 // FIXME: (or delete me) do we really want to cater to bad clients at the expense of good ones by BEEPing up their line breaks? commented.     $content = str_replace("\n", "\r\n", $content);
    1781 
    1782                 return $content;
    1783         }
    1784 
    1785         /**
    1786          * Updates the content of blog_filename.
    1787          *
    1788          * @since 1.5.0
    1789          *
    1790          * @param array $args Method parameters.
    1791          * @return bool True when done.
    1792          */
    1793         function blogger_setTemplate($args) {
    1794 
    1795                 $this->escape($args);
    1796 
    1797                 $blog_ID    = (int) $args[1];
    1798                 $username = $args[2];
    1799                 $password  = $args[3];
    1800                 $content    = $args[4];
    1801                 $template   = $args[5]; /* could be 'main' or 'archiveIndex', but we don't use it */
    1802 
    1803                 if ( !$user = $this->login($username, $password) )
    1804                         return $this->error;
    1805 
    1806                 do_action('xmlrpc_call', 'blogger.setTemplate');
    1807 
    1808                 if ( !current_user_can('edit_themes') )
    1809                         return new IXR_Error(401, __('Sorry, this user cannot edit the template.'));
    1810 
    1811                 /* warning: here we make the assumption that the blog's URL is on the same server */
    1812                 $filename = get_option('home') . '/';
    1813                 $filename = preg_replace('#https?://.+?/#', $_SERVER['DOCUMENT_ROOT'].'/', $filename);
    1814 
    1815                 if ($f = fopen($filename, 'w+')) {
    1816                         fwrite($f, $content);
    1817                         fclose($f);
    1818                 } else {
    1819                         return new IXR_Error(500, __('Either the file is not writable, or something wrong happened. The file has not been updated.'));
    1820                 }
    1821 
    1822                 return true;
    1823         }
    1824 
    1825         /**
    1826          * Create new post.
    1827          *
    1828          * @since 1.5.0
    1829          *
    1830          * @param array $args Method parameters.
    1831          * @return int
    1832          */
    1833         function blogger_newPost($args) {
    1834 
    1835                 $this->escape($args);
    1836 
    1837                 $blog_ID    = (int) $args[1]; /* though we don't use it yet */
    1838                 $username = $args[2];
    1839                 $password  = $args[3];
    1840                 $content    = $args[4];
    1841                 $publish    = $args[5];
    1842 
    1843                 if ( !$user = $this->login($username, $password) )
    1844                         return $this->error;
    1845 
    1846                 do_action('xmlrpc_call', 'blogger.newPost');
    1847 
    1848                 $cap = ($publish) ? 'publish_posts' : 'edit_posts';
    1849                 if ( !current_user_can($cap) )
    1850                         return new IXR_Error(401, __('Sorry, you are not allowed to post on this site.'));
    1851 
    1852                 $post_status = ($publish) ? 'publish' : 'draft';
    1853 
    1854                 $post_author = $user->ID;
    1855 
    1856                 $post_title = xmlrpc_getposttitle($content);
    1857                 $post_category = xmlrpc_getpostcategory($content);
    1858                 $post_content = xmlrpc_removepostdata($content);
    1859 
    1860                 $post_date = current_time('mysql');
    1861                 $post_date_gmt = current_time('mysql', 1);
    1862 
    1863                 $post_data = compact('blog_ID', 'post_author', 'post_date', 'post_date_gmt', 'post_content', 'post_title', 'post_category', 'post_status');
    1864 
    1865                 $post_ID = wp_insert_post($post_data);
    1866                 if ( is_wp_error( $post_ID ) )
    1867                         return new IXR_Error(500, $post_ID->get_error_message());
    1868 
    1869                 if ( !$post_ID )
    1870                         return new IXR_Error(500, __('Sorry, your entry could not be posted. Something wrong happened.'));
    1871 
    1872                 $this->attach_uploads( $post_ID, $post_content );
    1873 
    1874                 logIO('O', "Posted ! ID: $post_ID");
    1875 
    1876                 return $post_ID;
    1877         }
    1878 
    1879         /**
    1880          * Edit a post.
    1881          *
    1882          * @since 1.5.0
    1883          *
    1884          * @param array $args Method parameters.
    1885          * @return bool true when done.
    1886          */
    1887         function blogger_editPost($args) {
    1888 
    1889                 $this->escape($args);
    1890 
    1891                 $post_ID     = (int) $args[1];
    1892                 $username  = $args[2];
    1893                 $password   = $args[3];
    1894                 $content     = $args[4];
    1895                 $publish     = $args[5];
    1896 
    1897                 if ( !$user = $this->login($username, $password) )
    1898                         return $this->error;
    1899 
    1900                 do_action('xmlrpc_call', 'blogger.editPost');
    1901 
    1902                 $actual_post = wp_get_single_post($post_ID,ARRAY_A);
    1903 
    1904                 if ( !$actual_post || $actual_post['post_type'] != 'post' )
    1905                         return new IXR_Error(404, __('Sorry, no such post.'));
    1906 
    1907                 $this->escape($actual_post);
    1908 
    1909                 if ( !current_user_can('edit_post', $post_ID) )
    1910                         return new IXR_Error(401, __('Sorry, you do not have the right to edit this post.'));
    1911 
    1912                 extract($actual_post, EXTR_SKIP);
    1913 
    1914                 if ( ('publish' == $post_status) && !current_user_can('publish_posts') )
    1915                         return new IXR_Error(401, __('Sorry, you do not have the right to publish this post.'));
    1916 
    1917                 $post_title = xmlrpc_getposttitle($content);
    1918                 $post_category = xmlrpc_getpostcategory($content);
    1919                 $post_content = xmlrpc_removepostdata($content);
    1920 
    1921                 $postdata = compact('ID', 'post_content', 'post_title', 'post_category', 'post_status', 'post_excerpt');
    1922 
    1923                 $result = wp_update_post($postdata);
    1924 
    1925                 if ( !$result )
    1926                         return new IXR_Error(500, __('For some strange yet very annoying reason, this post could not be edited.'));
    1927 
    1928                 $this->attach_uploads( $ID, $post_content );
    1929 
    1930                 return true;
    1931         }
    1932 
    1933         /**
    1934          * Remove a post.
    1935          *
    1936          * @since 1.5.0
    1937          *
    1938          * @param array $args Method parameters.
    1939          * @return bool True when post is deleted.
    1940          */
    1941         function blogger_deletePost($args) {
    1942                 $this->escape($args);
    1943 
    1944                 $post_ID     = (int) $args[1];
    1945                 $username  = $args[2];
    1946                 $password   = $args[3];
    1947                 $publish     = $args[4];
    1948 
    1949                 if ( !$user = $this->login($username, $password) )
    1950                         return $this->error;
    1951 
    1952                 do_action('xmlrpc_call', 'blogger.deletePost');
    1953 
    1954                 $actual_post = wp_get_single_post($post_ID,ARRAY_A);
    1955 
    1956                 if ( !$actual_post || $actual_post['post_type'] != 'post' )
    1957                         return new IXR_Error(404, __('Sorry, no such post.'));
    1958 
    1959                 if ( !current_user_can('edit_post', $post_ID) )
    1960                         return new IXR_Error(401, __('Sorry, you do not have the right to delete this post.'));
    1961 
    1962                 $result = wp_delete_post($post_ID);
    1963 
    1964                 if ( !$result )
    1965                         return new IXR_Error(500, __('For some strange yet very annoying reason, this post could not be deleted.'));
    1966 
    1967                 return true;
    1968         }
    1969 
    1970         /* MetaWeblog API functions
    1971          * specs on wherever Dave Winer wants them to be
    1972          */
    1973 
    1974         /**
    1975          * Create a new post.
    1976          *
    1977          * @since 1.5.0
    1978          *
    1979          * @param array $args Method parameters.
    1980          * @return int
    1981          */
    1982         function mw_newPost($args) {
    1983                 $this->escape($args);
    1984 
    1985                 $blog_ID     = (int) $args[0]; // we will support this in the near future
    1986                 $username  = $args[1];
    1987                 $password   = $args[2];
    1988                 $content_struct = $args[3];
    1989                 $publish     = $args[4];
    1990 
    1991                 if ( !$user = $this->login($username, $password) )
    1992                         return $this->error;
    1993 
    1994                 do_action('xmlrpc_call', 'metaWeblog.newPost');
    1995 
    1996                 $cap = ( $publish ) ? 'publish_posts' : 'edit_posts';
    1997                 $error_message = __( 'Sorry, you are not allowed to publish posts on this site.' );
    1998                 $post_type = 'post';
    1999                 $page_template = '';
    2000                 if ( !empty( $content_struct['post_type'] ) ) {
    2001                         if ( $content_struct['post_type'] == 'page' ) {
    2002                                 $cap = ( $publish ) ? 'publish_pages' : 'edit_pages';
    2003                                 $error_message = __( 'Sorry, you are not allowed to publish pages on this site.' );
    2004                                 $post_type = 'page';
    2005                                 if ( !empty( $content_struct['wp_page_template'] ) )
    2006                                         $page_template = $content_struct['wp_page_template'];
    2007                         } elseif ( $content_struct['post_type'] == 'post' ) {
    2008                                 // This is the default, no changes needed
    2009                         } else {
    2010                                 // No other post_type values are allowed here
    2011                                 return new IXR_Error( 401, __( 'Invalid post type.' ) );
    2012                         }
    2013                 }
    2014 
    2015                 if ( !current_user_can( $cap ) )
    2016                         return new IXR_Error( 401, $error_message );
    2017 
    2018                 // Let WordPress generate the post_name (slug) unless
    2019                 // one has been provided.
    2020                 $post_name = "";
    2021                 if ( isset($content_struct["wp_slug"]) )
    2022                         $post_name = $content_struct["wp_slug"];
    2023 
    2024                 // Only use a password if one was given.
    2025                 if ( isset($content_struct["wp_password"]) )
    2026                         $post_password = $content_struct["wp_password"];
    2027 
    2028                 // Only set a post parent if one was provided.
    2029                 if ( isset($content_struct["wp_page_parent_id"]) )
    2030                         $post_parent = $content_struct["wp_page_parent_id"];
    2031 
    2032                 // Only set the menu_order if it was provided.
    2033                 if ( isset($content_struct["wp_page_order"]) )
    2034                         $menu_order = $content_struct["wp_page_order"];
    2035 
    2036                 $post_author = $user->ID;
    2037 
    2038                 // If an author id was provided then use it instead.
    2039                 if ( isset($content_struct["wp_author_id"]) && ($user->ID != $content_struct["wp_author_id"]) ) {
    2040                         switch ( $post_type ) {
    2041                                 case "post":
    2042                                         if ( !current_user_can("edit_others_posts") )
    2043                                                 return(new IXR_Error(401, __("You are not allowed to post as this user")));
    2044                                         break;
    2045                                 case "page":
    2046                                         if ( !current_user_can("edit_others_pages") )
    2047                                                 return(new IXR_Error(401, __("You are not allowed to create pages as this user")));
    2048                                         break;
    2049                                 default:
    2050                                         return(new IXR_Error(401, __("Invalid post type.")));
    2051                                         break;
    2052                         }
    2053                         $post_author = $content_struct["wp_author_id"];
    2054                 }
    2055 
    2056                 $post_title = $content_struct['title'];
    2057                 $post_content = $content_struct['description'];
    2058 
    2059                 $post_status = $publish ? 'publish' : 'draft';
    2060 
    2061                 if ( isset( $content_struct["{$post_type}_status"] ) ) {
    2062                         switch ( $content_struct["{$post_type}_status"] ) {
    2063                                 case 'draft':
    2064                                 case 'private':
    2065                                 case 'publish':
    2066                                         $post_status = $content_struct["{$post_type}_status"];
    2067                                         break;
    2068                                 case 'pending':
    2069                                         // Pending is only valid for posts, not pages.
    2070                                         if ( $post_type === 'post' )
    2071                                                 $post_status = $content_struct["{$post_type}_status"];
    2072                                         break;
    2073                                 default:
    2074                                         $post_status = $publish ? 'publish' : 'draft';
    2075                                         break;
    2076                         }
    2077                 }
    2078 
    2079                 $post_excerpt = $content_struct['mt_excerpt'];
    2080                 $post_more = $content_struct['mt_text_more'];
    2081 
    2082                 $tags_input = $content_struct['mt_keywords'];
    2083 
    2084                 if ( isset($content_struct["mt_allow_comments"]) ) {
    2085                         if ( !is_numeric($content_struct["mt_allow_comments"]) ) {
    2086                                 switch ( $content_struct["mt_allow_comments"] ) {
    2087                                         case "closed":
    2088                                                 $comment_status = "closed";
    2089                                                 break;
    2090                                         case "open":
    2091                                                 $comment_status = "open";
    2092                                                 break;
    2093                                         default:
    2094                                                 $comment_status = get_option("default_comment_status");
    2095                                                 break;
    2096                                 }
    2097                         } else {
    2098                                 switch ( (int) $content_struct["mt_allow_comments"] ) {
    2099                                         case 0:
    2100                                         case 2:
    2101                                                 $comment_status = "closed";
    2102                                                 break;
    2103                                         case 1:
    2104                                                 $comment_status = "open";
    2105                                                 break;
    2106                                         default:
    2107                                                 $comment_status = get_option("default_comment_status");
    2108                                                 break;
    2109                                 }
    2110                         }
    2111                 } else {
    2112                         $comment_status = get_option("default_comment_status");
    2113                 }
    2114 
    2115                 if ( isset($content_struct["mt_allow_pings"]) ) {
    2116                         if ( !is_numeric($content_struct["mt_allow_pings"]) ) {
    2117                                 switch ( $content_struct['mt_allow_pings'] ) {
    2118                                         case "closed":
    2119                                                 $ping_status = "closed";
    2120                                                 break;
    2121                                         case "open":
    2122                                                 $ping_status = "open";
    2123                                                 break;
    2124                                         default:
    2125                                                 $ping_status = get_option("default_ping_status");
    2126                                                 break;
    2127                                 }
    2128                         } else {
    2129                                 switch ( (int) $content_struct["mt_allow_pings"] ) {
    2130                                         case 0:
    2131                                                 $ping_status = "closed";
    2132                                                 break;
    2133                                         case 1:
    2134                                                 $ping_status = "open";
    2135                                                 break;
    2136                                         default:
    2137                                                 $ping_status = get_option("default_ping_status");
    2138                                                 break;
    2139                                 }
    2140                         }
    2141                 } else {
    2142                         $ping_status = get_option("default_ping_status");
    2143                 }
    2144 
    2145                 if ( $post_more )
    2146                         $post_content = $post_content . "<!--more-->" . $post_more;
    2147 
    2148                 $to_ping = $content_struct['mt_tb_ping_urls'];
    2149                 if ( is_array($to_ping) )
    2150                         $to_ping = implode(' ', $to_ping);
    2151 
    2152                 // Do some timestamp voodoo
    2153                 if ( !empty( $content_struct['date_created_gmt'] ) )
    2154                         $dateCreated = str_replace( 'Z', '', $content_struct['date_created_gmt']->getIso() ) . 'Z'; // We know this is supposed to be GMT, so we're going to slap that Z on there by force
    2155                 elseif ( !empty( $content_struct['dateCreated']) )
    2156                         $dateCreated = $content_struct['dateCreated']->getIso();
    2157 
    2158                 if ( !empty( $dateCreated ) ) {
    2159                         $post_date = get_date_from_gmt(iso8601_to_datetime($dateCreated));
    2160                         $post_date_gmt = iso8601_to_datetime($dateCreated, GMT);
    2161                 } else {
    2162                         $post_date = current_time('mysql');
    2163                         $post_date_gmt = current_time('mysql', 1);
    2164                 }
    2165 
    2166                 $catnames = $content_struct['categories'];
    2167                 logIO('O', 'Post cats: ' . var_export($catnames,true));
    2168                 $post_category = array();
    2169 
    2170                 if ( is_array($catnames) ) {
    2171                         foreach ($catnames as $cat) {
    2172                                 $post_category[] = get_cat_ID($cat);
    2173                         }
    2174                 }
    2175 
    2176                 // We've got all the data -- post it:
    2177                 $postdata = compact('post_author', 'post_date', 'post_date_gmt', 'post_content', 'post_title', 'post_category', 'post_status', 'post_excerpt', 'comment_status', 'ping_status', 'to_ping', 'post_type', 'post_name', 'post_password', 'post_parent', 'menu_order', 'tags_input', 'page_template');
    2178 
    2179                 $post_ID = wp_insert_post($postdata, true);
    2180                 if ( is_wp_error( $post_ID ) )
    2181                         return new IXR_Error(500, $post_ID->get_error_message());
    2182 
    2183                 if ( !$post_ID )
    2184                         return new IXR_Error(500, __('Sorry, your entry could not be posted. Something wrong happened.'));
    2185 
    2186                 // Only posts can be sticky
    2187                 if ( $post_type == 'post' && isset( $content_struct['sticky'] ) ) {
    2188                         if ( $content_struct['sticky'] == true )
    2189                                 stick_post( $post_ID );
    2190                         elseif ( $content_struct['sticky'] == false )
    2191                                 unstick_post( $post_ID );
    2192                 }
    2193 
    2194                 if ( isset($content_struct['custom_fields']) )
    2195                         $this->set_custom_fields($post_ID, $content_struct['custom_fields']);
    2196 
    2197                 // Handle enclosures
    2198                 $this->add_enclosure_if_new($post_ID, $content_struct['enclosure']);
    2199 
    2200                 $this->attach_uploads( $post_ID, $post_content );
    2201 
    2202                 logIO('O', "Posted ! ID: $post_ID");
    2203 
    2204                 return strval($post_ID);
    2205         }
    2206 
    2207         function add_enclosure_if_new($post_ID, $enclosure) {
    2208                 if ( is_array( $enclosure ) && isset( $enclosure['url'] ) && isset( $enclosure['length'] ) && isset( $enclosure['type'] ) ) {
    2209 
    2210                         $encstring = $enclosure['url'] . "\n" . $enclosure['length'] . "\n" . $enclosure['type'];
    2211                         $found = false;
    2212                         foreach ( (array) get_post_custom($post_ID) as $key => $val) {
    2213                                 if ($key == 'enclosure') {
    2214                                         foreach ( (array) $val as $enc ) {
    2215                                                 if ($enc == $encstring) {
    2216                                                         $found = true;
    2217                                                         break 2;
    2218                                                 }
    2219                                         }
    2220                                 }
    2221                         }
    2222                         if (!$found)
    2223                                 add_post_meta( $post_ID, 'enclosure', $encstring );
    2224                 }
    2225         }
    2226 
    2227         /**
    2228          * Attach upload to a post.
    2229          *
    2230          * @since 2.1.0
    2231          *
    2232          * @param int $post_ID Post ID.
    2233          * @param string $post_content Post Content for attachment.
    2234          */
    2235         function attach_uploads( $post_ID, $post_content ) {
    2236                 global $wpdb;
    2237 
    2238                 // find any unattached files
    2239                 $attachments = $wpdb->get_results( "SELECT ID, guid FROM {$wpdb->posts} WHERE post_parent = '0' AND post_type = 'attachment'" );
    2240                 if ( is_array( $attachments ) ) {
    2241                         foreach ( $attachments as $file ) {
    2242                                 if ( strpos( $post_content, $file->guid ) !== false )
    2243                                         $wpdb->update($wpdb->posts, array('post_parent' => $post_ID), array('ID' => $file->ID) );
    2244                         }
    2245                 }
    2246         }
    2247 
    2248         /**
    2249          * Edit a post.
    2250          *
    2251          * @since 1.5.0
    2252          *
    2253          * @param array $args Method parameters.
    2254          * @return bool True on success.
    2255          */
    2256         function mw_editPost($args) {
    2257 
    2258                 $this->escape($args);
    2259 
    2260                 $post_ID     = (int) $args[0];
    2261                 $username  = $args[1];
    2262                 $password   = $args[2];
    2263                 $content_struct = $args[3];
    2264                 $publish     = $args[4];
    2265 
    2266                 if ( !$user = $this->login($username, $password) )
    2267                         return $this->error;
    2268 
    2269                 do_action('xmlrpc_call', 'metaWeblog.editPost');
    2270 
    2271                 $cap = ( $publish ) ? 'publish_posts' : 'edit_posts';
    2272                 $error_message = __( 'Sorry, you are not allowed to publish posts on this site.' );
    2273                 $post_type = 'post';
    2274                 $page_template = '';
    2275                 if ( !empty( $content_struct['post_type'] ) ) {
    2276                         if ( $content_struct['post_type'] == 'page' ) {
    2277                                 $cap = ( $publish ) ? 'publish_pages' : 'edit_pages';
    2278                                 $error_message = __( 'Sorry, you are not allowed to publish pages on this site.' );
    2279                                 $post_type = 'page';
    2280                                 if ( !empty( $content_struct['wp_page_template'] ) )
    2281                                         $page_template = $content_struct['wp_page_template'];
    2282                         } elseif ( $content_struct['post_type'] == 'post' ) {
    2283                                 // This is the default, no changes needed
    2284                         } else {
    2285                                 // No other post_type values are allowed here
    2286                                 return new IXR_Error( 401, __( 'Invalid post type.' ) );
    2287                         }
    2288                 }
    2289 
    2290                 if ( !current_user_can( $cap ) )
    2291                         return new IXR_Error( 401, $error_message );
    2292 
    2293                 $postdata = wp_get_single_post($post_ID, ARRAY_A);
    2294 
    2295                 // If there is no post data for the give post id, stop
    2296                 // now and return an error.  Other wise a new post will be
    2297                 // created (which was the old behavior).
    2298                 if ( empty($postdata["ID"]) )
    2299                         return(new IXR_Error(404, __("Invalid post ID.")));
    2300 
    2301                 $this->escape($postdata);
    2302                 extract($postdata, EXTR_SKIP);
    2303 
    2304                 // Let WordPress manage slug if none was provided.
    2305                 $post_name = "";
    2306                 if ( isset($content_struct["wp_slug"]) )
    2307                         $post_name = $content_struct["wp_slug"];
    2308 
    2309                 // Only use a password if one was given.
    2310                 if ( isset($content_struct["wp_password"]) )
    2311                         $post_password = $content_struct["wp_password"];
    2312 
    2313                 // Only set a post parent if one was given.
    2314                 if ( isset($content_struct["wp_page_parent_id"]) )
    2315                         $post_parent = $content_struct["wp_page_parent_id"];
    2316 
    2317                 // Only set the menu_order if it was given.
    2318                 if ( isset($content_struct["wp_page_order"]) )
    2319                         $menu_order = $content_struct["wp_page_order"];
    2320 
    2321                 $post_author = $postdata["post_author"];
    2322 
    2323                 // Only set the post_author if one is set.
    2324                 if ( isset($content_struct["wp_author_id"]) && ($user->ID != $content_struct["wp_author_id"]) ) {
    2325                         switch ( $post_type ) {
    2326                                 case "post":
    2327                                         if ( !current_user_can("edit_others_posts") )
    2328                                                 return(new IXR_Error(401, __("You are not allowed to change the post author as this user.")));
    2329                                         break;
    2330                                 case "page":
    2331                                         if ( !current_user_can("edit_others_pages") )
    2332                                                 return(new IXR_Error(401, __("You are not allowed to change the page author as this user.")));
    2333                                         break;
    2334                                 default:
    2335                                         return(new IXR_Error(401, __("Invalid post type.")));
    2336                                         break;
    2337                         }
    2338                         $post_author = $content_struct["wp_author_id"];
    2339                 }
    2340 
    2341                 if ( isset($content_struct["mt_allow_comments"]) ) {
    2342                         if ( !is_numeric($content_struct["mt_allow_comments"]) ) {
    2343                                 switch ( $content_struct["mt_allow_comments"] ) {
    2344                                         case "closed":
    2345                                                 $comment_status = "closed";
    2346                                                 break;
    2347                                         case "open":
    2348                                                 $comment_status = "open";
    2349                                                 break;
    2350                                         default:
    2351                                                 $comment_status = get_option("default_comment_status");
    2352                                                 break;
    2353                                 }
    2354                         } else {
    2355                                 switch ( (int) $content_struct["mt_allow_comments"] ) {
    2356                                         case 0:
    2357                                         case 2:
    2358                                                 $comment_status = "closed";
    2359                                                 break;
    2360                                         case 1:
    2361                                                 $comment_status = "open";
    2362                                                 break;
    2363                                         default:
    2364                                                 $comment_status = get_option("default_comment_status");
    2365                                                 break;
    2366                                 }
    2367                         }
    2368                 }
    2369 
    2370                 if ( isset($content_struct["mt_allow_pings"]) ) {
    2371                         if ( !is_numeric($content_struct["mt_allow_pings"]) ) {
    2372                                 switch ( $content_struct["mt_allow_pings"] ) {
    2373                                         case "closed":
    2374                                                 $ping_status = "closed";
    2375                                                 break;
    2376                                         case "open":
    2377                                                 $ping_status = "open";
    2378                                                 break;
    2379                                         default:
    2380                                                 $ping_status = get_option("default_ping_status");
    2381                                                 break;
    2382                                 }
    2383                         } else {
    2384                                 switch ( (int) $content_struct["mt_allow_pings"] ) {
    2385                                         case 0:
    2386                                                 $ping_status = "closed";
    2387                                                 break;
    2388                                         case 1:
    2389                                                 $ping_status = "open";
    2390                                                 break;
    2391                                         default:
    2392                                                 $ping_status = get_option("default_ping_status");
    2393                                                 break;
    2394                                 }
    2395                         }
    2396                 }
    2397 
    2398                 $post_title = $content_struct['title'];
    2399                 $post_content = $content_struct['description'];
    2400                 $catnames = $content_struct['categories'];
    2401 
    2402                 $post_category = array();
    2403 
    2404                 if ( is_array($catnames) ) {
    2405                         foreach ($catnames as $cat) {
    2406                                 $post_category[] = get_cat_ID($cat);
    2407                         }
    2408                 }
    2409 
    2410                 $post_excerpt = $content_struct['mt_excerpt'];
    2411                 $post_more = $content_struct['mt_text_more'];
    2412 
    2413                 $post_status = $publish ? 'publish' : 'draft';
    2414                 if ( isset( $content_struct["{$post_type}_status"] ) ) {
    2415                         switch( $content_struct["{$post_type}_status"] ) {
    2416                                 case 'draft':
    2417                                 case 'private':
    2418                                 case 'publish':
    2419                                         $post_status = $content_struct["{$post_type}_status"];
    2420                                         break;
    2421                                 case 'pending':
    2422                                         // Pending is only valid for posts, not pages.
    2423                                         if ( $post_type === 'post' )
    2424                                                 $post_status = $content_struct["{$post_type}_status"];
    2425                                         break;
    2426                                 default:
    2427                                         $post_status = $publish ? 'publish' : 'draft';
    2428                                         break;
    2429                         }
    2430                 }
    2431 
    2432                 $tags_input = $content_struct['mt_keywords'];
    2433 
    2434                 if ( ('publish' == $post_status) ) {
    2435                         if ( ( 'page' == $post_type ) && !current_user_can('publish_pages') )
    2436                                 return new IXR_Error(401, __('Sorry, you do not have the right to publish this page.'));
    2437                         else if ( !current_user_can('publish_posts') )
    2438                                 return new IXR_Error(401, __('Sorry, you do not have the right to publish this post.'));
    2439                 }
    2440 
    2441                 if ( $post_more )
    2442                         $post_content = $post_content . "<!--more-->" . $post_more;
    2443 
    2444                 $to_ping = $content_struct['mt_tb_ping_urls'];
    2445                 if ( is_array($to_ping) )
    2446                         $to_ping = implode(' ', $to_ping);
    2447 
    2448                 // Do some timestamp voodoo
    2449                 if ( !empty( $content_struct['date_created_gmt'] ) )
    2450                         $dateCreated = str_replace( 'Z', '', $content_struct['date_created_gmt']->getIso() ) . 'Z'; // We know this is supposed to be GMT, so we're going to slap that Z on there by force
    2451                 elseif ( !empty( $content_struct['dateCreated']) )
    2452                         $dateCreated = $content_struct['dateCreated']->getIso();
    2453 
    2454                 if ( !empty( $dateCreated ) ) {
    2455                         $post_date = get_date_from_gmt(iso8601_to_datetime($dateCreated));
    2456                         $post_date_gmt = iso8601_to_datetime($dateCreated, GMT);
    2457                 } else {
    2458                         $post_date     = $postdata['post_date'];
    2459                         $post_date_gmt = $postdata['post_date_gmt'];
    2460                 }
    2461 
    2462                 // We've got all the data -- post it:
    2463                 $newpost = compact('ID', 'post_content', 'post_title', 'post_category', 'post_status', 'post_excerpt', 'comment_status', 'ping_status', 'post_date', 'post_date_gmt', 'to_ping', 'post_name', 'post_password', 'post_parent', 'menu_order', 'post_author', 'tags_input', 'page_template');
    2464 
    2465                 $result = wp_update_post($newpost, true);
    2466                 if ( is_wp_error( $result ) )
    2467                         return new IXR_Error(500, $result->get_error_message());
    2468 
    2469                 if ( !$result )
    2470                         return new IXR_Error(500, __('Sorry, your entry could not be edited. Something wrong happened.'));
    2471 
    2472                 // Only posts can be sticky
    2473                 if ( $post_type == 'post' && isset( $content_struct['sticky'] ) ) {
    2474                         if ( $content_struct['sticky'] == true )
    2475                                 stick_post( $post_ID );
    2476                         elseif ( $content_struct['sticky'] == false )
    2477                                 unstick_post( $post_ID );
    2478                 }
    2479 
    2480                 if ( isset($content_struct['custom_fields']) )
    2481                         $this->set_custom_fields($post_ID, $content_struct['custom_fields']);
    2482 
    2483                 // Handle enclosures
    2484                 $this->add_enclosure_if_new($post_ID, $content_struct['enclosure']);
    2485 
    2486                 $this->attach_uploads( $ID, $post_content );
    2487 
    2488                 logIO('O',"(MW) Edited ! ID: $post_ID");
    2489 
    2490                 return true;
    2491         }
    2492 
    2493         /**
    2494          * Retrieve post.
    2495          *
    2496          * @since 1.5.0
    2497          *
    2498          * @param array $args Method parameters.
    2499          * @return array
    2500          */
    2501         function mw_getPost($args) {
    2502 
    2503                 $this->escape($args);
    2504 
    2505                 $post_ID     = (int) $args[0];
    2506                 $username  = $args[1];
    2507                 $password   = $args[2];
    2508 
    2509                 if ( !$user = $this->login($username, $password) )
    2510                         return $this->error;
    2511 
    2512                 if ( !current_user_can( 'edit_post', $post_ID ) )
    2513                         return new IXR_Error( 401, __( 'Sorry, you cannot edit this post.' ) );
    2514 
    2515                 do_action('xmlrpc_call', 'metaWeblog.getPost');
    2516 
    2517                 $postdata = wp_get_single_post($post_ID, ARRAY_A);
    2518 
    2519                 if ($postdata['post_date'] != '') {
    2520                         $post_date = mysql2date('Ymd\TH:i:s', $postdata['post_date'], false);
    2521                         $post_date_gmt = mysql2date('Ymd\TH:i:s', $postdata['post_date_gmt'], false);
    2522 
    2523                         // For drafts use the GMT version of the post date
    2524                         if ( $postdata['post_status'] == 'draft' )
    2525                                 $post_date_gmt = get_gmt_from_date( mysql2date( 'Y-m-d H:i:s', $postdata['post_date'] ), 'Ymd\TH:i:s' );
    2526 
    2527                         $categories = array();
    2528                         $catids = wp_get_post_categories($post_ID);
    2529                         foreach($catids as $catid)
    2530                                 $categories[] = get_cat_name($catid);
    2531 
    2532                         $tagnames = array();
    2533                         $tags = wp_get_post_tags( $post_ID );
    2534                         if ( !empty( $tags ) ) {
    2535                                 foreach ( $tags as $tag )
    2536                                         $tagnames[] = $tag->name;
    2537                                 $tagnames = implode( ', ', $tagnames );
    2538                         } else {
    2539                                 $tagnames = '';
    2540                         }
    2541 
    2542                         $post = get_extended($postdata['post_content']);
    2543                         $link = post_permalink($postdata['ID']);
    2544 
    2545                         // Get the author info.
    2546                         $author = get_userdata($postdata['post_author']);
    2547 
    2548                         $allow_comments = ('open' == $postdata['comment_status']) ? 1 : 0;
    2549                         $allow_pings = ('open' == $postdata['ping_status']) ? 1 : 0;
    2550 
    2551                         // Consider future posts as published
    2552                         if ( $postdata['post_status'] === 'future' )
    2553                                 $postdata['post_status'] = 'publish';
    2554 
    2555                         $sticky = false;
    2556                         if ( is_sticky( $post_ID ) )
    2557                                 $sticky = true;
    2558 
    2559                         $enclosure = array();
    2560                         foreach ( (array) get_post_custom($post_ID) as $key => $val) {
    2561                                 if ($key == 'enclosure') {
    2562                                         foreach ( (array) $val as $enc ) {
    2563                                                 $encdata = split("\n", $enc);
    2564                                                 $enclosure['url'] = trim(htmlspecialchars($encdata[0]));
    2565                                                 $enclosure['length'] = (int) trim($encdata[1]);
    2566                                                 $enclosure['type'] = trim($encdata[2]);
    2567                                                 break 2;
    2568                                         }
    2569                                 }
    2570                         }
    2571 
    2572                         $resp = array(
    2573                                 'dateCreated' => new IXR_Date($post_date),
    2574                                 'userid' => $postdata['post_author'],
    2575                                 'postid' => $postdata['ID'],
    2576                                 'description' => $post['main'],
    2577                                 'title' => $postdata['post_title'],
    2578                                 'link' => $link,
    2579                                 'permaLink' => $link,
    2580                                 // commented out because no other tool seems to use this
    2581                                 //            'content' => $entry['post_content'],
    2582                                 'categories' => $categories,
    2583                                 'mt_excerpt' => $postdata['post_excerpt'],
    2584                                 'mt_text_more' => $post['extended'],
    2585                                 'mt_allow_comments' => $allow_comments,
    2586                                 'mt_allow_pings' => $allow_pings,
    2587                                 'mt_keywords' => $tagnames,
    2588                                 'wp_slug' => $postdata['post_name'],
    2589                                 'wp_password' => $postdata['post_password'],
    2590                                 'wp_author_id' => $author->ID,
    2591                                 'wp_author_display_name'        => $author->display_name,
    2592                                 'date_created_gmt' => new IXR_Date($post_date_gmt),
    2593                                 'post_status' => $postdata['post_status'],
    2594                                 'custom_fields' => $this->get_custom_fields($post_ID),
    2595                                 'sticky' => $sticky
    2596                         );
    2597 
    2598                         if ( !empty($enclosure) ) $resp['enclosure'] = $enclosure;
    2599 
    2600                         return $resp;
    2601                 } else {
    2602                         return new IXR_Error(404, __('Sorry, no such post.'));
    2603                 }
    2604         }
    2605 
    2606         /**
    2607          * Retrieve list of recent posts.
    2608          *
    2609          * @since 1.5.0
    2610          *
    2611          * @param array $args Method parameters.
    2612          * @return array
    2613          */
    2614         function mw_getRecentPosts($args) {
    2615 
    2616                 $this->escape($args);
    2617 
    2618                 $blog_ID     = (int) $args[0];
    2619                 $username  = $args[1];
    2620                 $password   = $args[2];
    2621                 $num_posts   = (int) $args[3];
    2622 
    2623                 if ( !$user = $this->login($username, $password) )
    2624                         return $this->error;
    2625 
    2626                 do_action('xmlrpc_call', 'metaWeblog.getRecentPosts');
    2627 
    2628                 $posts_list = wp_get_recent_posts($num_posts);
    2629 
    2630                 if ( !$posts_list )
    2631                         return array( );
    2632 
    2633                 foreach ($posts_list as $entry) {
    2634                         if ( !current_user_can( 'edit_post', $entry['ID'] ) )
    2635                                 continue;
    2636 
    2637                         $post_date = mysql2date('Ymd\TH:i:s', $entry['post_date'], false);
    2638                         $post_date_gmt = mysql2date('Ymd\TH:i:s', $entry['post_date_gmt'], false);
    2639 
    2640                         // For drafts use the GMT version of the date
    2641                         if ( $entry['post_status'] == 'draft' )
    2642                                 $post_date_gmt = get_gmt_from_date( mysql2date( 'Y-m-d H:i:s', $entry['post_date'] ), 'Ymd\TH:i:s' );
    2643 
    2644                         $categories = array();
    2645                         $catids = wp_get_post_categories($entry['ID']);
    2646                         foreach( $catids as $catid )
    2647                                 $categories[] = get_cat_name($catid);
    2648 
    2649                         $tagnames = array();
    2650                         $tags = wp_get_post_tags( $entry['ID'] );
    2651                         if ( !empty( $tags ) ) {
    2652                                 foreach ( $tags as $tag ) {
    2653                                         $tagnames[] = $tag->name;
    2654                                 }
    2655                                 $tagnames = implode( ', ', $tagnames );
    2656                         } else {
    2657                                 $tagnames = '';
    2658                         }
    2659 
    2660                         $post = get_extended($entry['post_content']);
    2661                         $link = post_permalink($entry['ID']);
    2662 
    2663                         // Get the post author info.
    2664                         $author = get_userdata($entry['post_author']);
    2665 
    2666                         $allow_comments = ('open' == $entry['comment_status']) ? 1 : 0;
    2667                         $allow_pings = ('open' == $entry['ping_status']) ? 1 : 0;
    2668 
    2669                         // Consider future posts as published
    2670                         if ( $entry['post_status'] === 'future' )
    2671                                 $entry['post_status'] = 'publish';
    2672 
    2673                         $struct[] = array(
    2674                                 'dateCreated' => new IXR_Date($post_date),
    2675                                 'userid' => $entry['post_author'],
    2676                                 'postid' => $entry['ID'],
    2677                                 'description' => $post['main'],
    2678                                 'title' => $entry['post_title'],
    2679                                 'link' => $link,
    2680                                 'permaLink' => $link,
    2681                                 // commented out because no other tool seems to use this
    2682                                 // 'content' => $entry['post_content'],
    2683                                 'categories' => $categories,
    2684                                 'mt_excerpt' => $entry['post_excerpt'],
    2685                                 'mt_text_more' => $post['extended'],
    2686                                 'mt_allow_comments' => $allow_comments,
    2687                                 'mt_allow_pings' => $allow_pings,
    2688                                 'mt_keywords' => $tagnames,
    2689                                 'wp_slug' => $entry['post_name'],
    2690                                 'wp_password' => $entry['post_password'],
    2691                                 'wp_author_id' => $author->ID,
    2692                                 'wp_author_display_name' => $author->display_name,
    2693                                 'date_created_gmt' => new IXR_Date($post_date_gmt),
    2694                                 'post_status' => $entry['post_status'],
    2695                                 'custom_fields' => $this->get_custom_fields($entry['ID'])
    2696                         );
    2697 
    2698                 }
    2699 
    2700                 $recent_posts = array();
    2701                 for ( $j=0; $j<count($struct); $j++ ) {
    2702                         array_push($recent_posts, $struct[$j]);
    2703                 }
    2704 
    2705                 return $recent_posts;
    2706         }
    2707 
    2708         /**
    2709          * Retrieve the list of categories on a given blog.
    2710          *
    2711          * @since 1.5.0
    2712          *
    2713          * @param array $args Method parameters.
    2714          * @return array
    2715          */
    2716         function mw_getCategories($args) {
    2717 
    2718                 $this->escape($args);
    2719 
    2720                 $blog_ID     = (int) $args[0];
    2721                 $username  = $args[1];
    2722                 $password   = $args[2];
    2723 
    2724                 if ( !$user = $this->login($username, $password) )
    2725                         return $this->error;
    2726 
    2727                 if ( !current_user_can( 'edit_posts' ) )
    2728                         return new IXR_Error( 401, __( 'Sorry, you must be able to edit posts on this site in order to view categories.' ) );
    2729 
    2730                 do_action('xmlrpc_call', 'metaWeblog.getCategories');
    2731 
    2732                 $categories_struct = array();
    2733 
    2734                 if ( $cats = get_categories(array('get' => 'all')) ) {
    2735                         foreach ( $cats as $cat ) {
    2736                                 $struct['categoryId'] = $cat->term_id;
    2737                                 $struct['parentId'] = $cat->parent;
    2738                                 $struct['description'] = $cat->name;
    2739                                 $struct['categoryDescription'] = $cat->description;
    2740                                 $struct['categoryName'] = $cat->name;
    2741                                 $struct['htmlUrl'] = esc_html(get_category_link($cat->term_id));
    2742                                 $struct['rssUrl'] = esc_html(get_category_feed_link($cat->term_id, 'rss2'));
    2743 
    2744                                 $categories_struct[] = $struct;
    2745                         }
    2746                 }
    2747 
    2748                 return $categories_struct;
    2749         }
    2750 
    2751         /**
    2752          * Uploads a file, following your settings.
    2753          *
    2754          * Adapted from a patch by Johann Richard.
    2755          *
    2756          * @link http://mycvs.org/archives/2004/06/30/file-upload-to-wordpress-in-ecto/
    2757          *
    2758          * @since 1.5.0
    2759          *
    2760          * @param array $args Method parameters.
    2761          * @return array
    2762          */
    2763         function mw_newMediaObject($args) {
    2764                 global $wpdb;
    2765 
    2766                 $blog_ID     = (int) $args[0];
    2767                 $username  = $wpdb->escape($args[1]);
    2768                 $password   = $wpdb->escape($args[2]);
    2769                 $data        = $args[3];
    2770 
    2771                 $name = sanitize_file_name( $data['name'] );
    2772                 $type = $data['type'];
    2773                 $bits = $data['bits'];
    2774 
    2775                 logIO('O', '(MW) Received '.strlen($bits).' bytes');
    2776 
    2777                 if ( !$user = $this->login($username, $password) )
    2778                         return $this->error;
    2779 
    2780                 do_action('xmlrpc_call', 'metaWeblog.newMediaObject');
    2781 
    2782                 if ( !current_user_can('upload_files') ) {
    2783                         logIO('O', '(MW) User does not have upload_files capability');
    2784                         $this->error = new IXR_Error(401, __('You are not allowed to upload files to this site.'));
    2785                         return $this->error;
    2786                 }
    2787 
    2788                 if ( $upload_err = apply_filters( "pre_upload_error", false ) )
    2789                         return new IXR_Error(500, $upload_err);
    2790 
    2791                 if ( !empty($data["overwrite"]) && ($data["overwrite"] == true) ) {
    2792                         // Get postmeta info on the object.
    2793                         $old_file = $wpdb->get_row("
    2794                                 SELECT ID
    2795                                 FROM {$wpdb->posts}
    2796                                 WHERE post_title = '{$name}'
    2797                                         AND post_type = 'attachment'
    2798                         ");
    2799 
    2800                         // Delete previous file.
    2801                         wp_delete_attachment($old_file->ID);
    2802 
    2803                         // Make sure the new name is different by pre-pending the
    2804                         // previous post id.
    2805                         $filename = preg_replace("/^wpid\d+-/", "", $name);
    2806                         $name = "wpid{$old_file->ID}-{$filename}";
    2807                 }
    2808 
    2809                 $upload = wp_upload_bits($name, $type, $bits);
    2810                 if ( ! empty($upload['error']) ) {
    2811                         $errorString = sprintf(__('Could not write file %1$s (%2$s)'), $name, $upload['error']);
    2812                         logIO('O', '(MW) ' . $errorString);
    2813                         return new IXR_Error(500, $errorString);
    2814                 }
    2815                 // Construct the attachment array
    2816                 // attach to post_id 0
    2817                 $post_id = 0;
    2818                 $attachment = array(
    2819                         'post_title' => $name,
    2820                         'post_content' => '',
    2821                         'post_type' => 'attachment',
    2822                         'post_parent' => $post_id,
    2823                         'post_mime_type' => $type,
    2824                         'guid' => $upload[ 'url' ]
    2825                 );
    2826 
    2827                 // Save the data
    2828                 $id = wp_insert_attachment( $attachment, $upload[ 'file' ], $post_id );
    2829                 wp_update_attachment_metadata( $id, wp_generate_attachment_metadata( $id, $upload['file'] ) );
    2830 
    2831                 return apply_filters( 'wp_handle_upload', array( 'file' => $name, 'url' => $upload[ 'url' ], 'type' => $type ), 'upload' );
    2832         }
    2833 
    2834         /* MovableType API functions
    2835          * specs on http://www.movabletype.org/docs/mtmanual_programmatic.html
    2836          */
    2837 
    2838         /**
    2839          * Retrieve the post titles of recent posts.
    2840          *
    2841          * @since 1.5.0
    2842          *
    2843          * @param array $args Method parameters.
    2844          * @return array
    2845          */
    2846         function mt_getRecentPostTitles($args) {
    2847 
    2848                 $this->escape($args);
    2849 
    2850                 $blog_ID     = (int) $args[0];
    2851                 $username  = $args[1];
    2852                 $password   = $args[2];
    2853                 $num_posts   = (int) $args[3];
    2854 
    2855                 if ( !$user = $this->login($username, $password) )
    2856                         return $this->error;
    2857 
    2858                 do_action('xmlrpc_call', 'mt.getRecentPostTitles');
    2859 
    2860                 $posts_list = wp_get_recent_posts($num_posts);
    2861 
    2862                 if ( !$posts_list ) {
    2863                         $this->error = new IXR_Error(500, __('Either there are no posts, or something went wrong.'));
    2864                         return $this->error;
    2865                 }
    2866 
    2867                 foreach ($posts_list as $entry) {
    2868                         if ( !current_user_can( 'edit_post', $entry['ID'] ) )
    2869                                 continue;
    2870 
    2871                         $post_date = mysql2date('Ymd\TH:i:s', $entry['post_date'], false);
    2872                         $post_date_gmt = mysql2date('Ymd\TH:i:s', $entry['post_date_gmt'], false);
    2873 
    2874                         // For drafts use the GMT version of the date
    2875                         if ( $entry['post_status'] == 'draft' )
    2876                                 $post_date_gmt = get_gmt_from_date( mysql2date( 'Y-m-d H:i:s', $entry['post_date'] ), 'Ymd\TH:i:s' );
    2877 
    2878                         $struct[] = array(
    2879                                 'dateCreated' => new IXR_Date($post_date),
    2880                                 'userid' => $entry['post_author'],
    2881                                 'postid' => $entry['ID'],
    2882                                 'title' => $entry['post_title'],
    2883                                 'date_created_gmt' => new IXR_Date($post_date_gmt)
    2884                         );
    2885 
    2886                 }
    2887 
    2888                 $recent_posts = array();
    2889                 for ( $j=0; $j<count($struct); $j++ ) {
    2890                         array_push($recent_posts, $struct[$j]);
    2891                 }
    2892 
    2893                 return $recent_posts;
    2894         }
    2895 
    2896         /**
    2897          * Retrieve list of all categories on blog.
    2898          *
    2899          * @since 1.5.0
    2900          *
    2901          * @param array $args Method parameters.
    2902          * @return array
    2903          */
    2904         function mt_getCategoryList($args) {
    2905 
    2906                 $this->escape($args);
    2907 
    2908                 $blog_ID     = (int) $args[0];
    2909                 $username  = $args[1];
    2910                 $password   = $args[2];
    2911 
    2912                 if ( !$user = $this->login($username, $password) )
    2913                         return $this->error;
    2914 
    2915                 if ( !current_user_can( 'edit_posts' ) )
    2916                         return new IXR_Error( 401, __( 'Sorry, you must be able to edit posts on this site in order to view categories.' ) );
    2917 
    2918                 do_action('xmlrpc_call', 'mt.getCategoryList');
    2919 
    2920                 $categories_struct = array();
    2921 
    2922                 if ( $cats = get_categories(array('hide_empty' => 0, 'hierarchical' => 0)) ) {
    2923                         foreach ( $cats as $cat ) {
    2924                                 $struct['categoryId'] = $cat->term_id;
    2925                                 $struct['categoryName'] = $cat->name;
    2926 
    2927                                 $categories_struct[] = $struct;
    2928                         }
    2929                 }
    2930 
    2931                 return $categories_struct;
    2932         }
    2933 
    2934         /**
    2935          * Retrieve post categories.
    2936          *
    2937          * @since 1.5.0
    2938          *
    2939          * @param array $args Method parameters.
    2940          * @return array
    2941          */
    2942         function mt_getPostCategories($args) {
    2943 
    2944                 $this->escape($args);
    2945 
    2946                 $post_ID     = (int) $args[0];
    2947                 $username  = $args[1];
    2948                 $password   = $args[2];
    2949 
    2950                 if ( !$user = $this->login($username, $password) )
    2951                         return $this->error;
    2952 
    2953                 if ( !current_user_can( 'edit_post', $post_ID ) )
    2954                         return new IXR_Error( 401, __( 'Sorry, you can not edit this post.' ) );
    2955 
    2956                 do_action('xmlrpc_call', 'mt.getPostCategories');
    2957 
    2958                 $categories = array();
    2959                 $catids = wp_get_post_categories(intval($post_ID));
    2960                 // first listed category will be the primary category
    2961                 $isPrimary = true;
    2962                 foreach ( $catids as $catid ) {
    2963                         $categories[] = array(
    2964                                 'categoryName' => get_cat_name($catid),
    2965                                 'categoryId' => (string) $catid,
    2966                                 'isPrimary' => $isPrimary
    2967                         );
    2968                         $isPrimary = false;
    2969                 }
    2970 
    2971                 return $categories;
    2972         }
    2973 
    2974         /**
    2975          * Sets categories for a post.
    2976          *
    2977          * @since 1.5.0
    2978          *
    2979          * @param array $args Method parameters.
    2980          * @return bool True on success.
    2981          */
    2982         function mt_setPostCategories($args) {
    2983 
    2984                 $this->escape($args);
    2985 
    2986                 $post_ID     = (int) $args[0];
    2987                 $username  = $args[1];
    2988                 $password   = $args[2];
    2989                 $categories  = $args[3];
    2990 
    2991                 if ( !$user = $this->login($username, $password) )
    2992                         return $this->error;
    2993 
    2994                 do_action('xmlrpc_call', 'mt.setPostCategories');
    2995 
    2996                 if ( !current_user_can('edit_post', $post_ID) )
    2997                         return new IXR_Error(401, __('Sorry, you cannot edit this post.'));
    2998 
    2999                 foreach ( $categories as $cat ) {
    3000                         $catids[] = $cat['categoryId'];
    3001                 }
    3002 
    3003                 wp_set_post_categories($post_ID, $catids);
    3004 
    3005                 return true;
    3006         }
    3007 
    3008         /**
    3009          * Retrieve an array of methods supported by this server.
    3010          *
    3011          * @since 1.5.0
    3012          *
    3013          * @param array $args Method parameters.
    3014          * @return array
    3015          */
    3016         function mt_supportedMethods($args) {
    3017 
    3018                 do_action('xmlrpc_call', 'mt.supportedMethods');
    3019 
    3020                 $supported_methods = array();
    3021                 foreach ( $this->methods as $key => $value ) {
    3022                         $supported_methods[] = $key;
    3023                 }
    3024 
    3025                 return $supported_methods;
    3026         }
    3027 
    3028         /**
    3029          * Retrieve an empty array because we don't support per-post text filters.
    3030          *
    3031          * @since 1.5.0
    3032          *
    3033          * @param array $args Method parameters.
    3034          */
    3035         function mt_supportedTextFilters($args) {
    3036                 do_action('xmlrpc_call', 'mt.supportedTextFilters');
    3037                 return apply_filters('xmlrpc_text_filters', array());
    3038         }
    3039 
    3040         /**
    3041          * Retrieve trackbacks sent to a given post.
    3042          *
    3043          * @since 1.5.0
    3044          *
    3045          * @param array $args Method parameters.
    3046          * @return mixed
    3047          */
    3048         function mt_getTrackbackPings($args) {
    3049 
    3050                 global $wpdb;
    3051 
    3052                 $post_ID = intval($args);
    3053 
    3054                 do_action('xmlrpc_call', 'mt.getTrackbackPings');
    3055 
    3056                 $actual_post = wp_get_single_post($post_ID, ARRAY_A);
    3057 
    3058                 if ( !$actual_post )
    3059                         return new IXR_Error(404, __('Sorry, no such post.'));
    3060 
    3061                 $comments = $wpdb->get_results( $wpdb->prepare("SELECT comment_author_url, comment_content, comment_author_IP, comment_type FROM $wpdb->comments WHERE comment_post_ID = %d", $post_ID) );
    3062 
    3063                 if ( !$comments )
    3064                         return array();
    3065 
    3066                 $trackback_pings = array();
    3067                 foreach ( $comments as $comment ) {
    3068                         if ( 'trackback' == $comment->comment_type ) {
    3069                                 $content = $comment->comment_content;
    3070                                 $title = substr($content, 8, (strpos($content, '</strong>') - 8));
    3071                                 $trackback_pings[] = array(
    3072                                         'pingTitle' => $title,
    3073                                         'pingURL'   => $comment->comment_author_url,
    3074                                         'pingIP'    => $comment->comment_author_IP
    3075                                 );
    3076                         }
    3077                 }
    3078 
    3079                 return $trackback_pings;
    3080         }
    3081 
    3082         /**
    3083          * Sets a post's publish status to 'publish'.
    3084          *
    3085          * @since 1.5.0
    3086          *
    3087          * @param array $args Method parameters.
    3088          * @return int
    3089          */
    3090         function mt_publishPost($args) {
    3091 
    3092                 $this->escape($args);
    3093 
    3094                 $post_ID     = (int) $args[0];
    3095                 $username  = $args[1];
    3096                 $password   = $args[2];
    3097 
    3098                 if ( !$user = $this->login($username, $password) )
    3099                         return $this->error;
    3100 
    3101                 do_action('xmlrpc_call', 'mt.publishPost');
    3102 
    3103                 if ( !current_user_can('edit_post', $post_ID) )
    3104                         return new IXR_Error(401, __('Sorry, you cannot edit this post.'));
    3105 
    3106                 $postdata = wp_get_single_post($post_ID,ARRAY_A);
    3107 
    3108                 $postdata['post_status'] = 'publish';
    3109 
    3110                 // retain old cats
    3111                 $cats = wp_get_post_categories($post_ID);
    3112                 $postdata['post_category'] = $cats;
    3113                 $this->escape($postdata);
    3114 
    3115                 $result = wp_update_post($postdata);
    3116 
    3117                 return $result;
    3118         }
    3119 
    3120         /* PingBack functions
    3121          * specs on www.hixie.ch/specs/pingback/pingback
    3122          */
    3123 
    3124         /**
    3125          * Retrieves a pingback and registers it.
    3126          *
    3127          * @since 1.5.0
    3128          *
    3129          * @param array $args Method parameters.
    3130          * @return array
    3131          */
    3132         function pingback_ping($args) {
    3133                 global $wpdb;
    3134 
    3135                 do_action('xmlrpc_call', 'pingback.ping');
    3136 
    3137                 $this->escape($args);
    3138 
    3139                 $pagelinkedfrom = $args[0];
    3140                 $pagelinkedto   = $args[1];
    3141 
    3142                 $title = '';
    3143 
    3144                 $pagelinkedfrom = str_replace('&amp;', '&', $pagelinkedfrom);
    3145                 $pagelinkedto = str_replace('&amp;', '&', $pagelinkedto);
    3146                 $pagelinkedto = str_replace('&', '&amp;', $pagelinkedto);
    3147 
    3148                 // Check if the page linked to is in our site
    3149                 $pos1 = strpos($pagelinkedto, str_replace(array('http://www.','http://','https://www.','https://'), '', get_option('home')));
    3150                 if ( !$pos1 )
    3151                         return new IXR_Error(0, __('Is there no link to us?'));
    3152 
    3153                 // let's find which post is linked to
    3154                 // FIXME: does url_to_postid() cover all these cases already?
    3155                 //        if so, then let's use it and drop the old code.
    3156                 $urltest = parse_url($pagelinkedto);
    3157                 if ( $post_ID = url_to_postid($pagelinkedto) ) {
    3158                         $way = 'url_to_postid()';
    3159                 } elseif ( preg_match('#p/[0-9]{1,}#', $urltest['path'], $match) ) {
    3160                         // the path defines the post_ID (archives/p/XXXX)
    3161                         $blah = explode('/', $match[0]);
    3162                         $post_ID = (int) $blah[1];
    3163                         $way = 'from the path';
    3164                 } elseif ( preg_match('#p=[0-9]{1,}#', $urltest['query'], $match) ) {
    3165                         // the querystring defines the post_ID (?p=XXXX)
    3166                         $blah = explode('=', $match[0]);
    3167                         $post_ID = (int) $blah[1];
    3168                         $way = 'from the querystring';
    3169                 } elseif ( isset($urltest['fragment']) ) {
    3170                         // an #anchor is there, it's either...
    3171                         if ( intval($urltest['fragment']) ) {
    3172                                 // ...an integer #XXXX (simpliest case)
    3173                                 $post_ID = (int) $urltest['fragment'];
    3174                                 $way = 'from the fragment (numeric)';
    3175                         } elseif ( preg_match('/post-[0-9]+/',$urltest['fragment']) ) {
    3176                                 // ...a post id in the form 'post-###'
    3177                                 $post_ID = preg_replace('/[^0-9]+/', '', $urltest['fragment']);
    3178                                 $way = 'from the fragment (post-###)';
    3179                         } elseif ( is_string($urltest['fragment']) ) {
    3180                                 // ...or a string #title, a little more complicated
    3181                                 $title = preg_replace('/[^a-z0-9]/i', '.', $urltest['fragment']);
    3182                                 $sql = $wpdb->prepare("SELECT ID FROM $wpdb->posts WHERE post_title RLIKE %s", $title);
    3183                                 if (! ($post_ID = $wpdb->get_var($sql)) ) {
    3184                                         // returning unknown error '0' is better than die()ing
    3185                                         return new IXR_Error(0, '');
    3186                                 }
    3187                                 $way = 'from the fragment (title)';
    3188                         }
    3189                 } else {
    3190                         // TODO: Attempt to extract a post ID from the given URL
    3191                         return new IXR_Error(33, __('The specified target URL cannot be used as a target. It either doesn&#8217;t exist, or it is not a pingback-enabled resource.'));
    3192                 }
    3193                 $post_ID = (int) $post_ID;
    3194 
    3195 
    3196                 logIO("O","(PB) URL='$pagelinkedto' ID='$post_ID' Found='$way'");
    3197 
    3198                 $post = get_post($post_ID);
    3199 
    3200                 if ( !$post ) // Post_ID not found
    3201                         return new IXR_Error(33, __('The specified target URL cannot be used as a target. It either doesn&#8217;t exist, or it is not a pingback-enabled resource.'));
    3202 
    3203                 if ( $post_ID == url_to_postid($pagelinkedfrom) )
    3204                         return new IXR_Error(0, __('The source URL and the target URL cannot both point to the same resource.'));
    3205 
    3206                 // Check if pings are on
    3207                 if ( !pings_open($post) )
    3208                         return new IXR_Error(33, __('The specified target URL cannot be used as a target. It either doesn&#8217;t exist, or it is not a pingback-enabled resource.'));
    3209 
    3210                 // Let's check that the remote site didn't already pingback this entry
    3211                 if ( $wpdb->get_results( $wpdb->prepare("SELECT * FROM $wpdb->comments WHERE comment_post_ID = %d AND comment_author_url = %s", $post_ID, $pagelinkedfrom) ) )
    3212                         return new IXR_Error( 48, __( 'The pingback has already been registered.' ) );
    3213 
    3214                 // very stupid, but gives time to the 'from' server to publish !
    3215                 sleep(1);
    3216 
    3217                 // Let's check the remote site
    3218                 $linea = wp_remote_fopen( $pagelinkedfrom );
    3219                 if ( !$linea )
    3220                         return new IXR_Error(16, __('The source URL does not exist.'));
    3221 
    3222                 $linea = apply_filters('pre_remote_source', $linea, $pagelinkedto);
    3223 
    3224                 // Work around bug in strip_tags():
    3225                 $linea = str_replace('<!DOC', '<DOC', $linea);
    3226                 $linea = preg_replace( '/[\s\r\n\t]+/', ' ', $linea ); // normalize spaces
    3227                 $linea = preg_replace( "/ <(h1|h2|h3|h4|h5|h6|p|th|td|li|dt|dd|pre|caption|input|textarea|button|body)[^>]*>/", "\n\n", $linea );
    3228 
    3229                 preg_match('|<title>([^<]*?)</title>|is', $linea, $matchtitle);
    3230                 $title = $matchtitle[1];
    3231                 if ( empty( $title ) )
    3232                         return new IXR_Error(32, __('We cannot find a title on that page.'));
    3233 
    3234                 $linea = strip_tags( $linea, '<a>' ); // just keep the tag we need
    3235 
    3236                 $p = explode( "\n\n", $linea );
    3237 
    3238                 $preg_target = preg_quote($pagelinkedto, '|');
    3239 
    3240                 foreach ( $p as $para ) {
    3241                         if ( strpos($para, $pagelinkedto) !== false ) { // it exists, but is it a link?
    3242                                 preg_match("|<a[^>]+?".$preg_target."[^>]*>([^>]+?)</a>|", $para, $context);
    3243 
    3244                                 // If the URL isn't in a link context, keep looking
    3245                                 if ( empty($context) )
    3246                                         continue;
    3247 
    3248                                 // We're going to use this fake tag to mark the context in a bit
    3249                                 // the marker is needed in case the link text appears more than once in the paragraph
    3250                                 $excerpt = preg_replace('|\</?wpcontext\>|', '', $para);
    3251 
    3252                                 // prevent really long link text
    3253                                 if ( strlen($context[1]) > 100 )
    3254                                         $context[1] = substr($context[1], 0, 100) . '...';
    3255 
    3256                                 $marker = '<wpcontext>'.$context[1].'</wpcontext>';    // set up our marker
    3257                                 $excerpt= str_replace($context[0], $marker, $excerpt); // swap out the link for our marker
    3258                                 $excerpt = strip_tags($excerpt, '<wpcontext>');        // strip all tags but our context marker
    3259                                 $excerpt = trim($excerpt);
    3260                                 $preg_marker = preg_quote($marker, '|');
    3261                                 $excerpt = preg_replace("|.*?\s(.{0,100}$preg_marker.{0,100})\s.*|s", '$1', $excerpt);
    3262                                 $excerpt = strip_tags($excerpt); // YES, again, to remove the marker wrapper
    3263                                 break;
    3264                         }
    3265                 }
    3266 
    3267                 if ( empty($context) ) // Link to target not found
    3268                         return new IXR_Error(17, __('The source URL does not contain a link to the target URL, and so cannot be used as a source.'));
    3269 
    3270                 $pagelinkedfrom = str_replace('&', '&amp;', $pagelinkedfrom);
    3271 
    3272                 $context = '[...] ' . esc_html( $excerpt ) . ' [...]';
    3273                 $pagelinkedfrom = $wpdb->escape( $pagelinkedfrom );
    3274 
    3275                 $comment_post_ID = (int) $post_ID;
    3276                 $comment_author = $title;
    3277                 $this->escape($comment_author);
    3278                 $comment_author_url = $pagelinkedfrom;
    3279                 $comment_content = $context;
    3280                 $this->escape($comment_content);
    3281                 $comment_type = 'pingback';
    3282 
    3283                 $commentdata = compact('comment_post_ID', 'comment_author', 'comment_author_url', 'comment_content', 'comment_type');
    3284 
    3285                 $comment_ID = wp_new_comment($commentdata);
    3286                 do_action('pingback_post', $comment_ID);
    3287 
    3288                 return sprintf(__('Pingback from %1$s to %2$s registered. Keep the web talking! :-)'), $pagelinkedfrom, $pagelinkedto);
    3289         }
    3290 
    3291         /**
    3292          * Retrieve array of URLs that pingbacked the given URL.
    3293          *
    3294          * Specs on http://www.aquarionics.com/misc/archives/blogite/0198.html
    3295          *
    3296          * @since 1.5.0
    3297          *
    3298          * @param array $args Method parameters.
    3299          * @return array
    3300          */
    3301         function pingback_extensions_getPingbacks($args) {
    3302 
    3303                 global $wpdb;
    3304 
    3305                 do_action('xmlrpc_call', 'pingback.extensions.getPingbacks');
    3306 
    3307                 $this->escape($args);
    3308 
    3309                 $url = $args;
    3310 
    3311                 $post_ID = url_to_postid($url);
    3312                 if ( !$post_ID ) {
    3313                         // We aren't sure that the resource is available and/or pingback enabled
    3314                         return new IXR_Error(33, __('The specified target URL cannot be used as a target. It either doesn&#8217;t exist, or it is not a pingback-enabled resource.'));
    3315                 }
    3316 
    3317                 $actual_post = wp_get_single_post($post_ID, ARRAY_A);
    3318 
    3319                 if ( !$actual_post ) {
    3320                         // No such post = resource not found
    3321                         return new IXR_Error(32, __('The specified target URL does not exist.'));
    3322                 }
    3323 
    3324                 $comments = $wpdb->get_results( $wpdb->prepare("SELECT comment_author_url, comment_content, comment_author_IP, comment_type FROM $wpdb->comments WHERE comment_post_ID = %d", $post_ID) );
    3325 
    3326                 if ( !$comments )
    3327                         return array();
    3328 
    3329                 $pingbacks = array();
    3330                 foreach ( $comments as $comment ) {
    3331                         if ( 'pingback' == $comment->comment_type )
    3332                                 $pingbacks[] = $comment->comment_author_url;
    3333                 }
    3334 
    3335                 return $pingbacks;
    3336         }
    3337 }
    3338 
    3339 $wp_xmlrpc_server = new wp_xmlrpc_server();
     105// Fire off the request
    3340106$wp_xmlrpc_server->serve_request();
    3341107?>
Note: See TracChangeset for help on using the changeset viewer.