xmlrpc.php

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