<?php

define('XMLRPC_REQUEST', true);

// Some browser-embedded clients send cookies. We don't want them.

$_COOKIE = array();

// A bug in PHP < 5.2.2 makes $HTTP_RAW_POST_DATA not set by default,

// but we can do it ourself.

if ( !isset( $HTTP_RAW_POST_DATA ) ) {

$HTTP_RAW_POST_DATA = file_get_contents( 'php://input' );

}

# fix for mozBlog and other cases where '<?xml' isn't on the very first line

if ( isset($HTTP_RAW_POST_DATA) )

$HTTP_RAW_POST_DATA = trim($HTTP_RAW_POST_DATA);

include('./wp-config.php');

if ( isset( $_GET['rsd'] ) ) { // http://archipelago.phrasewise.com/rsd

header('Content-Type: text/xml; charset=' . get_option('blog_charset'), true);

?>

<?php echo '<?xml version="1.0" encoding="'.get_option('blog_charset').'"?'.'>'; ?>

<rsd version="1.0" xmlns="http://archipelago.phrasewise.com/rsd">

<service>

<engineName>WordPress</engineName>

<engineLink>http://wordpress.org/</engineLink>

<homePageLink><?php bloginfo_rss('url') ?></homePageLink>

<apis>

<api name="WordPress" blogID="1" preferred="true" apiLink="<?php bloginfo_rss('wpurl') ?>/xmlrpc.php" />

<api name="Movable Type" blogID="1" preferred="false" apiLink="<?php bloginfo_rss('wpurl') ?>/xmlrpc.php" />

<api name="MetaWeblog" blogID="1" preferred="false" apiLink="<?php bloginfo_rss('wpurl') ?>/xmlrpc.php" />

<api name="Blogger" blogID="1" preferred="false" apiLink="<?php bloginfo_rss('wpurl') ?>/xmlrpc.php" />

</apis>

</service>

</rsd>

<?php

exit;

}

include_once(ABSPATH . 'wp-admin/includes/admin.php');

include_once(ABSPATH . WPINC . '/class-IXR.php');

// Turn off all warnings and errors.

// error_reporting(0);

$post_default_title = ""; // posts submitted via the xmlrpc interface get that title

$xmlrpc_logging = 0;

function logIO($io,$msg) {

global $xmlrpc_logging;

if ($xmlrpc_logging) {

$fp = fopen("../xmlrpc.log","a+");

$date = gmdate("Y-m-d H:i:s ");

$iot = ($io == "I") ? " Input: " : " Output: ";

fwrite($fp, "\n\n".$date.$iot.$msg);

fclose($fp);

}

return true;

}

function starify($string) {

$i = strlen($string);

return str_repeat('*', $i);

}

if ( isset($HTTP_RAW_POST_DATA) )

logIO("I", $HTTP_RAW_POST_DATA);

class wp_xmlrpc_server extends IXR_Server {

function wp_xmlrpc_server() {

$this->methods = array(

// WordPress API

'wp.getPage' => 'this:wp_getPage',

'wp.getPages' => 'this:wp_getPages',

'wp.newPage' => 'this:wp_newPage',

'wp.deletePage' => 'this:wp_deletePage',

'wp.editPage' => 'this:wp_editPage',

'wp.getPageList' => 'this:wp_getPageList',

'wp.getAuthors' => 'this:wp_getAuthors',

'wp.getCategories' => 'this:mw_getCategories', // Alias

'wp.newCategory' => 'this:wp_newCategory',

'wp.suggestCategories' => 'this:wp_suggestCategories',

'wp.uploadFile' => 'this:mw_newMediaObject', // Alias

// Blogger API

'blogger.getUsersBlogs' => 'this:blogger_getUsersBlogs',

'blogger.getUserInfo' => 'this:blogger_getUserInfo',

'blogger.getPost' => 'this:blogger_getPost',

'blogger.getRecentPosts' => 'this:blogger_getRecentPosts',

'blogger.getTemplate' => 'this:blogger_getTemplate',

'blogger.setTemplate' => 'this:blogger_setTemplate',

'blogger.newPost' => 'this:blogger_newPost',

'blogger.editPost' => 'this:blogger_editPost',

'blogger.deletePost' => 'this:blogger_deletePost',

// MetaWeblog API (with MT extensions to structs)

'metaWeblog.newPost' => 'this:mw_newPost',

'metaWeblog.editPost' => 'this:mw_editPost',

'metaWeblog.getPost' => 'this:mw_getPost',

'metaWeblog.getRecentPosts' => 'this:mw_getRecentPosts',

'metaWeblog.getCategories' => 'this:mw_getCategories',

'metaWeblog.newMediaObject' => 'this:mw_newMediaObject',

// MetaWeblog API aliases for Blogger API

// see http://www.xmlrpc.com/stories/storyReader$2460

'metaWeblog.deletePost' => 'this:blogger_deletePost',

'metaWeblog.getTemplate' => 'this:blogger_getTemplate',

'metaWeblog.setTemplate' => 'this:blogger_setTemplate',

'metaWeblog.getUsersBlogs' => 'this:blogger_getUsersBlogs',

// MovableType API

'mt.getCategoryList' => 'this:mt_getCategoryList',

'mt.getRecentPostTitles' => 'this:mt_getRecentPostTitles',

'mt.getPostCategories' => 'this:mt_getPostCategories',

'mt.setPostCategories' => 'this:mt_setPostCategories',

'mt.supportedMethods' => 'this:mt_supportedMethods',

'mt.supportedTextFilters' => 'this:mt_supportedTextFilters',

'mt.getTrackbackPings' => 'this:mt_getTrackbackPings',

'mt.publishPost' => 'this:mt_publishPost',

// PingBack

'pingback.ping' => 'this:pingback_ping',

'pingback.extensions.getPingbacks' => 'this:pingback_extensions_getPingbacks',

'demo.sayHello' => 'this:sayHello',

'demo.addTwoNumbers' => 'this:addTwoNumbers'

);

$this->methods = apply_filters('xmlrpc_methods', $this->methods);

$this->IXR_Server($this->methods);

}

function sayHello($args) {

return 'Hello!';

}

function addTwoNumbers($args) {

$number1 = $args[0];

$number2 = $args[1];

return $number1 + $number2;

}

function login_pass_ok($user_login, $user_pass) {

if (!user_pass_ok($user_login, $user_pass)) {

$this->error = new IXR_Error(403, __('Bad login/pass combination.'));

return false;

}

return true;

}

function escape(&$array) {

global $wpdb;

if(!is_array($array)) {

return($wpdb->escape($array));

}

else {

foreach ( (array) $array as $k => $v ) {

if (is_array($v)) {

$this->escape($array[$k]);

} else if (is_object($v)) {

//skip

} else {

$array[$k] = $wpdb->escape($v);

}

}

}

}

/**

* WordPress XML-RPC API

* wp_getPage

*/

function wp_getPage($args) {

$this->escape($args);

$blog_id = (int) $args[0];

$page_id = (int) $args[1];

$username = $args[2];

$password = $args[3];

if(!$this->login_pass_ok($username, $password)) {

return($this->error);

}

set_current_user( 0, $username );

if( !current_user_can( 'edit_page', $page_id ) )

return new IXR_Error( 401, __( 'Sorry, you can not edit this page.' ) );

do_action('xmlrpc_call', 'wp.getPage');

// Lookup page info.

$page = get_page($page_id);

// If we found the page then format the data.

if($page->ID && ($page->post_type == "page")) {

// Get all of the page content and link.

$full_page = get_extended($page->post_content);

$link = post_permalink($page->ID);

// Get info the page parent if there is one.

$parent_title = "";

if(!empty($page->post_parent)) {

$parent = get_page($page->post_parent);

$parent_title = $parent->post_title;

}

// Determine comment and ping settings.

$allow_comments = ("open" == $page->comment_status) ? 1 : 0;

$allow_pings = ("open" == $page->ping_status) ? 1 : 0;

// Format page date.

$page_date = mysql2date("Ymd\TH:i:s", $page->post_date);

$page_date_gmt = mysql2date("Ymd\TH:i:s", $page->post_date_gmt);

// Pull the categories info together.

$categories = array();

foreach(wp_get_post_categories($page->ID) as $cat_id) {

$categories[] = get_cat_name($cat_id);

}

// Get the author info.

$author = get_userdata($page->post_author);

$page_struct = array(

"dateCreated" => new IXR_Date($page_date),

"userid" => $page->post_author,

"page_id" => $page->ID,

"page_status" => $page->post_status,

"description" => $full_page["main"],

"title" => $page->post_title,

"link" => $link,

"permaLink" => $link,

"categories" => $categories,

"excerpt" => $page->post_excerpt,

"text_more" => $full_page["extended"],

"mt_allow_comments" => $allow_comments,

"mt_allow_pings" => $allow_pings,

"wp_slug" => $page->post_name,

"wp_password" => $page->post_password,

"wp_author" => $author->display_name,

"wp_page_parent_id" => $page->post_parent,

"wp_page_parent_title" => $parent_title,

"wp_page_order" => $page->menu_order,

"wp_author_id" => $author->ID,

"wp_author_display_name" => $author->display_name,

"date_created_gmt" => new IXR_Date($page_date_gmt)

);

return($page_struct);

}

// If the page doesn't exist indicate that.

else {

return(new IXR_Error(404, __("Sorry, no such page.")));

}

}

/**

* WordPress XML-RPC API

* wp_getPages

*/

function wp_getPages($args) {

$this->escape($args);

$blog_id = (int) $args[0];

$username = $args[1];

$password = $args[2];

if(!$this->login_pass_ok($username, $password)) {

return($this->error);

}

set_current_user( 0, $username );

if( !current_user_can( 'edit_pages' ) )

return new IXR_Error( 401, __( 'Sorry, you can not edit pages.' ) );

do_action('xmlrpc_call', 'wp.getPages');

// Lookup info on pages.

$pages = get_pages();

$num_pages = count($pages);

// If we have pages, put together their info.

if($num_pages >= 1) {

$pages_struct = array();

for($i = 0; $i < $num_pages; $i++) {

$page = wp_xmlrpc_server::wp_getPage(array(

$blog_id, $pages[$i]->ID, $username, $password

));

$pages_struct[] = $page;

}

return($pages_struct);

}

// If no pages were found return an error.

else {

return(array());

}

}

/**

* WordPress XML-RPC API

* wp_newPage

*/

function wp_newPage($args) {

// Items not escaped here will be escaped in newPost.

$username = $this->escape($args[1]);

$password = $this->escape($args[2]);

$page = $args[3];

$publish = $args[4];

if(!$this->login_pass_ok($username, $password)) {

return($this->error);

}

// Set the user context and check if they are allowed

// to add new pages.

$user = set_current_user(0, $username);

if(!current_user_can("publish_pages")) {

return(new IXR_Error(401, __("Sorry, you can not add new pages.")));

}

// Mark this as content for a page.

$args[3]["post_type"] = "page";

// Let mw_newPost do all of the heavy lifting.

return($this->mw_newPost($args));

}

/**

* WordPress XML-RPC API

* wp_deletePage

*/

function wp_deletePage($args) {

$this->escape($args);

$blog_id = (int) $args[0];

$username = $args[1];

$password = $args[2];

$page_id = (int) $args[3];

if(!$this->login_pass_ok($username, $password)) {

return($this->error);

}

// Get the current page based on the page_id and

// make sure it is a page and not a post.

$actual_page = wp_get_single_post($page_id, ARRAY_A);

if(

!$actual_page

|| ($actual_page["post_type"] != "page")

) {

return(new IXR_Error(404, __("Sorry, no such page.")));

}

// Set the user context and make sure they can delete pages.

set_current_user(0, $username);

if(!current_user_can("delete_page", $page_id)) {

return(new IXR_Error(401, __("Sorry, you do not have the right to delete this page.")));

}

// Attempt to delete the page.

$result = wp_delete_post($page_id);

if(!$result) {

return(new IXR_Error(500, __("Failed to delete the page.")));

}

return(true);

}

/**

* WordPress XML-RPC API

* wp_editPage

*/

function wp_editPage($args) {

// Items not escaped here will be escaped in editPost.

$blog_id = (int) $args[0];

$page_id = (int) $this->escape($args[1]);

$username = $this->escape($args[2]);

$password = $this->escape($args[3]);

$content = $args[4];

$publish = $args[5];

if(!$this->login_pass_ok($username, $password)) {

return($this->error);

}

// Get the page data and make sure it is a page.

$actual_page = wp_get_single_post($page_id, ARRAY_A);

if(

!$actual_page

|| ($actual_page["post_type"] != "page")

) {

return(new IXR_Error(404, __("Sorry, no such page.")));

}

// Set the user context and make sure they are allowed to edit pages.

set_current_user(0, $username);

if(!current_user_can("edit_page", $page_id)) {

return(new IXR_Error(401, __("Sorry, you do not have the right to edit this page.")));

}

// Mark this as content for a page.

$content["post_type"] = "page";

// Arrange args in the way mw_editPost understands.

$args = array(

$page_id,

$username,

$password,

$content,

$publish

);

// Let mw_editPost do all of the heavy lifting.

return($this->mw_editPost($args));

}

/**

* WordPress XML-RPC API

* wp_getPageList

*/

function wp_getPageList($args) {

global $wpdb;

$this->escape($args);

$blog_id = (int) $args[0];

$username = $args[1];

$password = $args[2];

if(!$this->login_pass_ok($username, $password)) {

return($this->error);

}

set_current_user( 0, $username );

if( !current_user_can( 'edit_pages' ) )

return new IXR_Error( 401, __( 'Sorry, you can not edit pages.' ) );

do_action('xmlrpc_call', 'wp.getPageList');

// Get list of pages ids and titles

$page_list = $wpdb->get_results("

SELECT ID page_id,

post_title page_title,

post_parent page_parent_id,

post_date_gmt,

post_date

FROM {$wpdb->posts}

WHERE post_type = 'page'

ORDER BY ID

");

// The date needs to be formated properly.

$num_pages = count($page_list);

for($i = 0; $i < $num_pages; $i++) {

$post_date = mysql2date("Ymd\TH:i:s", $page_list[$i]->post_date);

$post_date_gmt = mysql2date("Ymd\TH:i:s", $page_list[$i]->post_date_gmt);

$page_list[$i]->dateCreated = new IXR_Date($post_date);

$page_list[$i]->date_created_gmt = new IXR_Date($post_date_gmt);

unset($page_list[$i]->post_date_gmt);

unset($page_list[$i]->post_date);

}

return($page_list);

}

/**

* WordPress XML-RPC API

* wp_getAuthors

*/

function wp_getAuthors($args) {

$this->escape($args);

$blog_id = (int) $args[0];

$username = $args[1];

$password = $args[2];

if(!$this->login_pass_ok($username, $password)) {

return($this->error);

}

set_current_user(0, $username);

if(!current_user_can("edit_posts")) {

return(new IXR_Error(401, __("Sorry, you can not edit posts on this blog.")));

}

do_action('xmlrpc_call', 'wp.getAuthors');

$authors = array();

foreach( (array) get_users_of_blog() as $row ) {

$authors[] = array(

"user_id" => $row->user_id,

"user_login" => $row->user_login,

"display_name" => $row->display_name

);

}

return($authors);

}

/**

* WordPress XML-RPC API

* wp_newCategory

*/

function wp_newCategory($args) {

$this->escape($args);

$blog_id = (int) $args[0];

$username = $args[1];

$password = $args[2];

$category = $args[3];

if(!$this->login_pass_ok($username, $password)) {

return($this->error);

}

// Set the user context and make sure they are

// allowed to add a category.

set_current_user(0, $username);

if(!current_user_can("manage_categories")) {

return(new IXR_Error(401, __("Sorry, you do not have the right to add a category.")));

}

// If no slug was provided make it empty so that

// WordPress will generate one.

if(empty($category["slug"])) {

$category["slug"] = "";

}

// If no parent_id was provided make it empty

// so that it will be a top level page (no parent).

if ( !isset($category["parent_id"]) )

$category["parent_id"] = "";

// If no description was provided make it empty.

if(empty($category["description"])) {

$category["description"] = "";

}

$new_category = array(

"cat_name" => $category["name"],

"category_nicename" => $category["slug"],

"category_parent" => $category["parent_id"],

"category_description" => $category["description"]

);

$cat_id = wp_insert_category($new_category);

if(!$cat_id) {

return(new IXR_Error(500, __("Sorry, the new category failed.")));

}

return($cat_id);

}

/**

* WordPress XML-RPC API

* wp_suggestCategories

*/

function wp_suggestCategories($args) {

global $wpdb;

$this->escape($args);

$blog_id = (int) $args[0];

$username = $args[1];

$password = $args[2];

$category = $args[3];

$max_results = (int) $args[4];

if(!$this->login_pass_ok($username, $password)) {

return($this->error);

}

set_current_user(0, $username);

if( !current_user_can( 'edit_posts' ) )

return new IXR_Error( 401, __( 'Sorry, you must be able to publish to this blog in order to view categories.' ) );

do_action('xmlrpc_call', 'wp.suggestCategories');

$args = array('get' => 'all', 'number' => $max_results, 'name__like' => $category);

$category_suggestions = get_categories($args);

return($category_suggestions);

}

/* Blogger API functions

* specs on http://plant.blogger.com/api and http://groups.yahoo.com/group/bloggerDev/

*/

/* blogger.getUsersBlogs will make more sense once we support multiple blogs */

function blogger_getUsersBlogs($args) {

$this->escape($args);

$user_login = $args[1];

$user_pass = $args[2];

if (!$this->login_pass_ok($user_login, $user_pass)) {

return $this->error;

}

set_current_user(0, $user_login);

$is_admin = current_user_can('level_8');

$struct = array(

'isAdmin' => $is_admin,

'url' => get_option('home') . '/',

'blogid' => '1',

'blogName' => get_option('blogname')

);

return array($struct);

}

/* blogger.getUsersInfo gives your client some info about you, so you don't have to */

function blogger_getUserInfo($args) {

$this->escape($args);

$user_login = $args[1];

$user_pass = $args[2];

if (!$this->login_pass_ok($user_login, $user_pass)) {

return $this->error;

}

set_current_user( 0, $user_login );

if( !current_user_can( 'edit_posts' ) )

return new IXR_Error( 401, __( 'Sorry, you do not have access to user data on this blog.' ) );

do_action('xmlrpc_call', 'blogger.getUserInfo');

$user_data = get_userdatabylogin($user_login);

$struct = array(

'nickname' => $user_data->nickname,

'userid' => $user_data->ID,

'url' => $user_data->user_url,

'lastname' => $user_data->last_name,

'firstname' => $user_data->first_name

);

return $struct;

}

/* blogger.getPost ...gets a post */

function blogger_getPost($args) {

$this->escape($args);

$post_ID = (int) $args[1];

$user_login = $args[2];

$user_pass = $args[3];

if (!$this->login_pass_ok($user_login, $user_pass)) {

return $this->error;

}

set_current_user( 0, $user_login );

if( !current_user_can( 'edit_post', $post_ID ) )

return new IXR_Error( 401, __( 'Sorry, you can not edit this post.' ) );

do_action('xmlrpc_call', 'blogger.getPost');

$post_data = wp_get_single_post($post_ID, ARRAY_A);

$categories = implode(',', wp_get_post_categories($post_ID));

$content = '<title>'.stripslashes($post_data['post_title']).'</title>';

$content .= '<category>'.$categories.'</category>';

$content .= stripslashes($post_data['post_content']);

$struct = array(

'userid' => $post_data['post_author'],

'dateCreated' => new IXR_Date(mysql2date('Ymd\TH:i:s', $post_data['post_date'])),

'content' => $content,

'postid' => $post_data['ID']

);

return $struct;

}

/* blogger.getRecentPosts ...gets recent posts */

function blogger_getRecentPosts($args) {

global $wpdb;

$this->escape($args);

$blog_ID = (int) $args[1]; /* though we don't use it yet */

$user_login = $args[2];

$user_pass = $args[3];

$num_posts = $args[4];

if (!$this->login_pass_ok($user_login, $user_pass)) {

return $this->error;

}

$posts_list = wp_get_recent_posts($num_posts);

set_current_user( 0, $user_login );

if (!$posts_list) {

$this->error = new IXR_Error(500, __('Either there are no posts, or something went wrong.'));

return $this->error;

}

foreach ($posts_list as $entry) {

if( !current_user_can( 'edit_post', $entry['ID'] ) )

continue;

$post_date = mysql2date('Ymd\TH:i:s', $entry['post_date']);

$categories = implode(',', wp_get_post_categories($entry['ID']));

$content = '<title>'.stripslashes($entry['post_title']).'</title>';

$content .= '<category>'.$categories.'</category>';

$content .= stripslashes($entry['post_content']);

$struct[] = array(

'userid' => $entry['post_author'],

'dateCreated' => new IXR_Date($post_date),

'content' => $content,

'postid' => $entry['ID'],

);

}

$recent_posts = array();

for ($j=0; $j<count($struct); $j++) {

array_push($recent_posts, $struct[$j]);

}

return $recent_posts;

}

/* blogger.getTemplate returns your blog_filename */

function blogger_getTemplate($args) {

$this->escape($args);

$blog_ID = (int) $args[1];

$user_login = $args[2];

$user_pass = $args[3];

$template = $args[4]; /* could be 'main' or 'archiveIndex', but we don't use it */

if (!$this->login_pass_ok($user_login, $user_pass)) {

return $this->error;

}

set_current_user(0, $user_login);

if ( !current_user_can('edit_themes') ) {

return new IXR_Error(401, __('Sorry, this user can not edit the template.'));

}

/* warning: here we make the assumption that the blog's URL is on the same server */

$filename = get_option('home') . '/';

$filename = preg_replace('#https?://.+?/#', $_SERVER['DOCUMENT_ROOT'].'/', $filename);

$f = fopen($filename, 'r');

$content = fread($f, filesize($filename));

fclose($f);

/* so it is actually editable with a windows/mac client */

// 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);

return $content;

}

/* blogger.setTemplate updates the content of blog_filename */

function blogger_setTemplate($args) {

$this->escape($args);

$blog_ID = (int) $args[1];

$user_login = $args[2];

$user_pass = $args[3];

$content = $args[4];

$template = $args[5]; /* could be 'main' or 'archiveIndex', but we don't use it */

if (!$this->login_pass_ok($user_login, $user_pass)) {

return $this->error;

}

set_current_user(0, $user_login);

if ( !current_user_can('edit_themes') ) {

return new IXR_Error(401, __('Sorry, this user can not edit the template.'));

}

/* warning: here we make the assumption that the blog's URL is on the same server */

$filename = get_option('home') . '/';

$filename = preg_replace('#https?://.+?/#', $_SERVER['DOCUMENT_ROOT'].'/', $filename);

if ($f = fopen($filename, 'w+')) {

fwrite($f, $content);

fclose($f);

} else {

return new IXR_Error(500, __('Either the file is not writable, or something wrong happened. The file has not been updated.'));

}

return true;

}

/* blogger.newPost ...creates a new post */

function blogger_newPost($args) {

global $wpdb;

$this->escape($args);

$blog_ID = (int) $args[1]; /* though we don't use it yet */

$user_login = $args[2];

$user_pass = $args[3];

$content = $args[4];

$publish = $args[5];

if (!$this->login_pass_ok($user_login, $user_pass)) {

return $this->error;

}

$cap = ($publish) ? 'publish_posts' : 'edit_posts';

$user = set_current_user(0, $user_login);

if ( !current_user_can($cap) )

return new IXR_Error(401, __('Sorry, you are not allowed to post on this blog.'));

$post_status = ($publish) ? 'publish' : 'draft';

$post_author = $user->ID;

$post_title = xmlrpc_getposttitle($content);

$post_category = xmlrpc_getpostcategory($content);

$post_content = xmlrpc_removepostdata($content);

$post_date = current_time('mysql');

$post_date_gmt = current_time('mysql', 1);

$post_data = compact('blog_ID', 'post_author', 'post_date', 'post_date_gmt', 'post_content', 'post_title', 'post_category', 'post_status');

$post_ID = wp_insert_post($post_data);

if ( is_wp_error( $post_ID ) )

return new IXR_Error(500, $post_ID->get_error_message());

if (!$post_ID) {

return new IXR_Error(500, __('Sorry, your entry could not be posted. Something wrong happened.'));

}

$this->attach_uploads( $post_ID, $post_content );

logIO('O', "Posted ! ID: $post_ID");

return $post_ID;

}

/* blogger.editPost ...edits a post */

function blogger_editPost($args) {

global $wpdb;

$this->escape($args);

$post_ID = (int) $args[1];

$user_login = $args[2];

$user_pass = $args[3];

$content = $args[4];

$publish = $args[5];

if (!$this->login_pass_ok($user_login, $user_pass)) {

return $this->error;

}

$actual_post = wp_get_single_post($post_ID,ARRAY_A);

if (!$actual_post) {

return new IXR_Error(404, __('Sorry, no such post.'));

}

$this->escape($actual_post);

set_current_user(0, $user_login);

if ( !current_user_can('edit_post', $post_ID) )

return new IXR_Error(401, __('Sorry, you do not have the right to edit this post.'));

extract($actual_post, EXTR_SKIP);

if ( ('publish' == $post_status) && !current_user_can('publish_posts') )

return new IXR_Error(401, __('Sorry, you do not have the right to publish this post.'));

$post_title = xmlrpc_getposttitle($content);

$post_category = xmlrpc_getpostcategory($content);

$post_content = xmlrpc_removepostdata($content);

$postdata = compact('ID', 'post_content', 'post_title', 'post_category', 'post_status', 'post_excerpt');

$result = wp_update_post($postdata);

if (!$result) {

return new IXR_Error(500, __('For some strange yet very annoying reason, this post could not be edited.'));

}

$this->attach_uploads( $ID, $post_content );

return true;

}

/* blogger.deletePost ...deletes a post */

function blogger_deletePost($args) {

global $wpdb;

$this->escape($args);

$post_ID = (int) $args[1];

$user_login = $args[2];

$user_pass = $args[3];

$publish = $args[4];

if (!$this->login_pass_ok($user_login, $user_pass)) {

return $this->error;

}

$actual_post = wp_get_single_post($post_ID,ARRAY_A);

if (!$actual_post) {

return new IXR_Error(404, __('Sorry, no such post.'));

}

set_current_user(0, $user_login);

if ( !current_user_can('edit_post', $post_ID) )

return new IXR_Error(401, __('Sorry, you do not have the right to delete this post.'));

$result = wp_delete_post($post_ID);

if (!$result) {

return new IXR_Error(500, __('For some strange yet very annoying reason, this post could not be deleted.'));

}

return true;

}

/* MetaWeblog API functions

* specs on wherever Dave Winer wants them to be

*/

/* metaweblog.newPost creates a post */

function mw_newPost($args) {

global $wpdb, $post_default_category;

$this->escape($args);

$blog_ID = (int) $args[0]; // we will support this in the near future

$user_login = $args[1];

$user_pass = $args[2];

$content_struct = $args[3];

$publish = $args[4];

if (!$this->login_pass_ok($user_login, $user_pass)) {

return $this->error;

}

$user = set_current_user(0, $user_login);

$cap = ( $publish ) ? 'publish_posts' : 'edit_posts';

$error_message = __( 'Sorry, you are not allowed to publish posts on this blog.' );

$post_type = 'post';

if( !empty( $content_struct['post_type'] ) ) {

if( $content_struct['post_type'] == 'page' ) {

$cap = ( $publish ) ? 'publish_pages' : 'edit_pages';

$error_message = __( 'Sorry, you are not allowed to publish pages on this blog.' );

$post_type = 'page';

}

elseif( $content_struct['post_type'] == 'post' ) {

// This is the default, no changes needed

}

else {

// No other post_type values are allowed here

return new IXR_Error( 401, __( 'Invalid post type.' ) );

}

}

if( !current_user_can( $cap ) ) {

return new IXR_Error( 401, $error_message );

}