1 <?php

     2 /**

     3  * XML-RPC protocol support for WordPress

     4  *

     5  * @package WordPress

     6  */

     7 

     8 /**

     9  * WordPress XMLRPC server implementation.

    10  *

    11  * Implements compatibility for Blogger API, MetaWeblog API, MovableType, and

    12  * pingback. Additional WordPress API for managing comments, pages, posts,

    13  * options, etc.

    14  *

    15  * Since WordPress 2.6.0, WordPress XMLRPC server can be disabled in the

    16  * administration panels.

    17  *

    18  * @package WordPress

    19  * @subpackage Publishing

    20  * @since 1.5.0

    21  */

    22 class wp_xmlrpc_server extends IXR_Server {

    23 

    24 	/**

    25 	 * Register all of the XMLRPC methods that XMLRPC server understands.

    26 	 *

    27 	 * Sets up server and method property. Passes XMLRPC

    28 	 * methods through the 'xmlrpc_methods' filter to allow plugins to extend

    29 	 * or replace XMLRPC methods.

    30 	 *

    31 	 * @since 1.5.0

    32 	 *

    33 	 * @return wp_xmlrpc_server

    34 	 */

    35 	function __construct() {

    36 		$this->methods = array(

    37 			// WordPress API

    38 			'wp.getUsersBlogs'		=> 'this:wp_getUsersBlogs',

    39 			'wp.newPost'			=> 'this:wp_newPost',

    40 			'wp.editPost'			=> 'this:wp_editPost',

    41 			'wp.deletePost'			=> 'this:wp_deletePost',

    42 			'wp.getPost'			=> 'this:wp_getPost',

    43 			'wp.getPosts'			=> 'this:wp_getPosts',

    44 			'wp.newTerm'			=> 'this:wp_newTerm',

    45 			'wp.editTerm'			=> 'this:wp_editTerm',

    46 			'wp.deleteTerm'			=> 'this:wp_deleteTerm',

    47 			'wp.getTerm'			=> 'this:wp_getTerm',

    48 			'wp.getTerms'			=> 'this:wp_getTerms',

    49 			'wp.getTaxonomy'		=> 'this:wp_getTaxonomy',

    50 			'wp.getTaxonomies'		=> 'this:wp_getTaxonomies',

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

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

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

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

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

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

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

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

    59 			'wp.getTags'			=> 'this:wp_getTags',

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

    61 			'wp.deleteCategory'		=> 'this:wp_deleteCategory',

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

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

    64 			'wp.getCommentCount'	=> 'this:wp_getCommentCount',

    65 			'wp.getPostStatusList'	=> 'this:wp_getPostStatusList',

    66 			'wp.getPageStatusList'	=> 'this:wp_getPageStatusList',

    67 			'wp.getPageTemplates'	=> 'this:wp_getPageTemplates',

    68 			'wp.getOptions'			=> 'this:wp_getOptions',

    69 			'wp.setOptions'			=> 'this:wp_setOptions',

    70 			'wp.getComment'			=> 'this:wp_getComment',

    71 			'wp.getComments'		=> 'this:wp_getComments',

    72 			'wp.deleteComment'		=> 'this:wp_deleteComment',

    73 			'wp.editComment'		=> 'this:wp_editComment',

    74 			'wp.newComment'			=> 'this:wp_newComment',

    75 			'wp.getCommentStatusList' => 'this:wp_getCommentStatusList',

    76 			'wp.getMediaItem'		=> 'this:wp_getMediaItem',

    77 			'wp.getMediaLibrary'	=> 'this:wp_getMediaLibrary',

    78 			'wp.getPostFormats'     => 'this:wp_getPostFormats',

    79 			'wp.getPostType'		=> 'this:wp_getPostType',

    80 			'wp.getPostTypes'		=> 'this:wp_getPostTypes',

    81 

    82 			// Blogger API

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

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

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

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

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

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

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

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

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

    92 

    93 			// MetaWeblog API (with MT extensions to structs)

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

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

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

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

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

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

   100 

   101 			// MetaWeblog API aliases for Blogger API

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

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

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

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

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

   107 

   108 			// MovableType API

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

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

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

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

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

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

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

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

   117 

   118 			// PingBack

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

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

   121 

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

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

   124 		);

   125 

   126 		$this->initialise_blog_option_info();

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

   128 	}

   129 

   130 	function serve_request() {

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

   132 	}

   133 

   134 	/**

   135 	 * Test XMLRPC API by saying, "Hello!" to client.

   136 	 *

   137 	 * @since 1.5.0

   138 	 *

   139 	 * @param array $args Method Parameters.

   140 	 * @return string

   141 	 */

   142 	function sayHello($args) {

   143 		return 'Hello!';

   144 	}

   145 

   146 	/**

   147 	 * Test XMLRPC API by adding two numbers for client.

   148 	 *

   149 	 * @since 1.5.0

   150 	 *

   151 	 * @param array $args Method Parameters.

   152 	 * @return int

   153 	 */

   154 	function addTwoNumbers($args) {

   155 		$number1 = $args[0];

   156 		$number2 = $args[1];

   157 		return $number1 + $number2;

   158 	}

   159 

   160 	/**

   161 	 * Check user's credentials.

   162 	 *

   163 	 * @since 1.5.0

   164 	 *

   165 	 * @param string $user_login User's username.

   166 	 * @param string $user_pass User's password.

   167 	 * @return bool Whether authentication passed.

   168 	 * @deprecated use wp_xmlrpc_server::login

   169 	 * @see wp_xmlrpc_server::login

   170 	 */

   171 	function login_pass_ok($user_login, $user_pass) {

   172 		if ( !get_option( 'enable_xmlrpc' ) ) {

   173 			$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') ) );

   174 			return false;

   175 		}

   176 

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

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

   179 			return false;

   180 		}

   181 		return true;

   182 	}

   183 

   184 	/**

   185 	 * Log user in.

   186 	 *

   187 	 * @since 2.8

   188 	 *

   189 	 * @param string $username User's username.

   190 	 * @param string $password User's password.

   191 	 * @return mixed WP_User object if authentication passed, false otherwise

   192 	 */

   193 	function login($username, $password) {

   194 		if ( !get_option( 'enable_xmlrpc' ) ) {

   195 			$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') ) );

   196 			return false;

   197 		}

   198 

   199 		$user = wp_authenticate($username, $password);

   200 

   201 		if (is_wp_error($user)) {

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

   203 			return false;

   204 		}

   205 

   206 		wp_set_current_user( $user->ID );

   207 		return $user;

   208 	}

   209 

   210 	/**

   211 	 * Sanitize string or array of strings for database.

   212 	 *

   213 	 * @since 1.5.2

   214 	 *

   215 	 * @param string|array $array Sanitize single string or array of strings.

   216 	 * @return string|array Type matches $array and sanitized for the database.

   217 	 */

   218 	function escape(&$array) {

   219 		global $wpdb;

   220 

   221 		if (!is_array($array)) {

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

   223 		} else {

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

   225 				if ( is_array($v) ) {

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

   227 				} else if ( is_object($v) ) {

   228 					//skip

   229 				} else {

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

   231 				}

   232 			}

   233 		}

   234 	}

   235 

   236 	/**

   237 	 * Retrieve custom fields for post.

   238 	 *

   239 	 * @since 2.5.0

   240 	 *

   241 	 * @param int $post_id Post ID.

   242 	 * @return array Custom fields, if exist.

   243 	 */

   244 	function get_custom_fields($post_id) {

   245 		$post_id = (int) $post_id;

   246 

   247 		$custom_fields = array();

   248 

   249 		foreach ( (array) has_meta($post_id) as $meta ) {

   250 			// Don't expose protected fields.

   251 			if ( ! current_user_can( 'edit_post_meta', $post_id , $meta['meta_key'] ) )

   252 				continue;

   253 

   254 			$custom_fields[] = array(

   255 				"id"    => $meta['meta_id'],

   256 				"key"   => $meta['meta_key'],

   257 				"value" => $meta['meta_value']

   258 			);

   259 		}

   260 

   261 		return $custom_fields;

   262 	}

   263 

   264 	/**

   265 	 * Set custom fields for post.

   266 	 *

   267 	 * @since 2.5.0

   268 	 *

   269 	 * @param int $post_id Post ID.

   270 	 * @param array $fields Custom fields.

   271 	 */

   272 	function set_custom_fields($post_id, $fields) {

   273 		$post_id = (int) $post_id;

   274 

   275 		foreach ( (array) $fields as $meta ) {

   276 			if ( isset($meta['id']) ) {

   277 				$meta['id'] = (int) $meta['id'];

   278 				$pmeta = get_metadata_by_mid( 'post', $meta['id'] );

   279 				if ( isset($meta['key']) ) {

   280 					$meta['key'] = stripslashes( $meta['key'] );

   281 					if ( $meta['key'] != $pmeta->meta_key )

   282 						continue;

   283 					$meta['value'] = stripslashes_deep( $meta['value'] );

   284 					if ( current_user_can( 'edit_post_meta', $post_id, $meta['key'] ) )

   285 						update_metadata_by_mid( 'post', $meta['id'], $meta['value'] );

   286 				} elseif ( current_user_can( 'delete_post_meta', $post_id, $pmeta->meta_key ) ) {

   287 					delete_metadata_by_mid( 'post', $meta['id'] );

   288 				}

   289 			} elseif ( current_user_can( 'add_post_meta', $post_id, stripslashes( $meta['key'] ) ) ) {

   290 				add_post_meta( $post_id, $meta['key'], $meta['value'] );

   291 			}

   292 		}

   293 	}

   294 

   295 	/**

   296 	 * Set up blog options property.

   297 	 *

   298 	 * Passes property through 'xmlrpc_blog_options' filter.

   299 	 *

   300 	 * @since 2.6.0

   301 	 */

   302 	function initialise_blog_option_info() {

   303 		global $wp_version;

   304 

   305 		$this->blog_options = array(

   306 			// Read only options

   307 			'software_name'     => array(

   308 				'desc'          => __( 'Software Name' ),

   309 				'readonly'      => true,

   310 				'value'         => 'WordPress'

   311 			),

   312 			'software_version'  => array(

   313 				'desc'          => __( 'Software Version' ),

   314 				'readonly'      => true,

   315 				'value'         => $wp_version

   316 			),

   317 			'blog_url'          => array(

   318 				'desc'          => __( 'Site URL' ),

   319 				'readonly'      => true,

   320 				'option'        => 'siteurl'

   321 			),

   322 			'image_default_link_type' => array(

   323 				'desc'          => __( 'Image default link type' ),

   324 				'readonly'      => true,

   325 				'option'        => 'image_default_link_type'

   326 			),

   327 			'image_default_size' => array(

   328 				'desc'          => __( 'Image default size' ),

   329 				'readonly'      => true,

   330 				'option'        => 'image_default_size'

   331 			),

   332 			'image_default_align' => array(

   333 				'desc'          => __( 'Image default align' ),

   334 				'readonly'      => true,

   335 				'option'        => 'image_default_align'

   336 			),

   337 			'template'          => array(

   338 				'desc'          => __( 'Template' ),

   339 				'readonly'      => true,

   340 				'option'        => 'template'

   341 			),

   342 			'stylesheet'        => array(

   343 				'desc'          => __( 'Stylesheet' ),

   344 				'readonly'      => true,

   345 				'option'        => 'stylesheet'

   346 			),

   347 			'post_thumbnail'    => array(

   348 				'desc'          => __('Post Thumbnail'),

   349 				'readonly'      => true,

   350 				'value'         => current_theme_supports( 'post-thumbnails' )

   351 			),

   352 

   353 			// Updatable options

   354 			'time_zone'         => array(

   355 				'desc'          => __( 'Time Zone' ),

   356 				'readonly'      => false,

   357 				'option'        => 'gmt_offset'

   358 			),

   359 			'blog_title'        => array(

   360 				'desc'          => __( 'Site Title' ),

   361 				'readonly'      => false,

   362 				'option'        => 'blogname'

   363 			),

   364 			'blog_tagline'      => array(

   365 				'desc'          => __( 'Site Tagline' ),

   366 				'readonly'      => false,

   367 				'option'        => 'blogdescription'

   368 			),

   369 			'date_format'       => array(

   370 				'desc'          => __( 'Date Format' ),

   371 				'readonly'      => false,

   372 				'option'        => 'date_format'

   373 			),

   374 			'time_format'       => array(

   375 				'desc'          => __( 'Time Format' ),

   376 				'readonly'      => false,

   377 				'option'        => 'time_format'

   378 			),

   379 			'users_can_register' => array(

   380 				'desc'          => __( 'Allow new users to sign up' ),

   381 				'readonly'      => false,

   382 				'option'        => 'users_can_register'

   383 			),

   384 			'thumbnail_size_w'  => array(

   385 				'desc'          => __( 'Thumbnail Width' ),

   386 				'readonly'      => false,

   387 				'option'        => 'thumbnail_size_w'

   388 			),

   389 			'thumbnail_size_h'  => array(

   390 				'desc'          => __( 'Thumbnail Height' ),

   391 				'readonly'      => false,

   392 				'option'        => 'thumbnail_size_h'

   393 			),

   394 			'thumbnail_crop'    => array(

   395 				'desc'          => __( 'Crop thumbnail to exact dimensions' ),

   396 				'readonly'      => false,

   397 				'option'        => 'thumbnail_crop'

   398 			),

   399 			'medium_size_w'     => array(

   400 				'desc'          => __( 'Medium size image width' ),

   401 				'readonly'      => false,

   402 				'option'        => 'medium_size_w'

   403 			),

   404 			'medium_size_h'     => array(

   405 				'desc'          => __( 'Medium size image height' ),

   406 				'readonly'      => false,

   407 				'option'        => 'medium_size_h'

   408 			),

   409 			'large_size_w'      => array(

   410 				'desc'          => __( 'Large size image width' ),

   411 				'readonly'      => false,

   412 				'option'        => 'large_size_w'

   413 			),

   414 			'large_size_h'      => array(

   415 				'desc'          => __( 'Large size image height' ),

   416 				'readonly'      => false,

   417 				'option'        => 'large_size_h'

   418 			),

   419 			'default_comment_status' => array(

   420 				'desc'          => __( 'Allow people to post comments on new articles' ),

   421 				'readonly'      => false,

   422 				'option'        => 'default_comment_status'

   423 			),

   424 			'default_ping_status' => array(

   425 				'desc'          => __( 'Allow link notifications from other blogs (pingbacks and trackbacks)' ),

   426 				'readonly'      => false,

   427 				'option'        => 'default_ping_status'

   428 			)

   429 		);

   430 

   431 		$this->blog_options = apply_filters( 'xmlrpc_blog_options', $this->blog_options );

   432 	}

   433 

   434 	/**

   435 	 * Retrieve the blogs of the user.

   436 	 *

   437 	 * @since 2.6.0

   438 	 *

   439 	 * @param array $args Method parameters. Contains:

   440 	 *  - username

   441 	 *  - password

   442 	 * @return array. Contains:

   443 	 *  - 'isAdmin'

   444 	 *  - 'url'

   445 	 *  - 'blogid'

   446 	 *  - 'blogName'

   447 	 *  - 'xmlrpc' - url of xmlrpc endpoint

   448 	 */

   449 	function wp_getUsersBlogs( $args ) {

   450 		global $current_site;

   451 		// If this isn't on WPMU then just use blogger_getUsersBlogs

   452 		if ( !is_multisite() ) {

   453 			array_unshift( $args, 1 );

   454 			return $this->blogger_getUsersBlogs( $args );

   455 		}

   456 

   457 		$this->escape( $args );

   458 

   459 		$username = $args[0];

   460 		$password = $args[1];

   461 

   462 		if ( !$user = $this->login($username, $password) )

   463 			return $this->error;

   464 

   465 		do_action( 'xmlrpc_call', 'wp.getUsersBlogs' );

   466 

   467 		$blogs = (array) get_blogs_of_user( $user->ID );

   468 		$struct = array();

   469 

   470 		foreach ( $blogs as $blog ) {

   471 			// Don't include blogs that aren't hosted at this site

   472 			if ( $blog->site_id != $current_site->id )

   473 				continue;

   474 

   475 			$blog_id = $blog->userblog_id;

   476 			switch_to_blog($blog_id);

   477 			$is_admin = current_user_can('manage_options');

   478 

   479 			$struct[] = array(

   480 				'isAdmin'		=> $is_admin,

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

   482 				'blogid'		=> (string) $blog_id,

   483 				'blogName'		=> get_option( 'blogname' ),

   484 				'xmlrpc'		=> site_url( 'xmlrpc.php' )

   485 			);

   486 

   487 			restore_current_blog();

   488 		}

   489 

   490 		return $struct;

   491 	}

   492 

   493 	/**

   494 	 * Checks if the method received at least the minimum number of arguments.

   495 	 *

   496 	 * @since 3.4.0

   497 	 *

   498 	 * @param string|array $args Sanitize single string or array of strings.

   499 	 * @param int $count Minimum number of arguments.

   500 	 * @return boolean if $args contains at least $count arguments.

   501 	 */

   502 	protected function minimum_args( $args, $count ) {

   503 		if ( count( $args ) < $count ) {

   504 			$this->error = new IXR_Error( 400, __( 'Insufficient arguments passed to this XML-RPC method.' ) );

   505 			return false;

   506 		}

   507 

   508 		return true;

   509 	}

   510 

   511 	/**

   512 	 * Prepares taxonomy data for return in an XML-RPC object.

   513 	 *

   514 	 * @access protected

   515 	 *

   516 	 * @param object $taxonomy The unprepared taxonomy data

   517 	 * @param array $fields The subset of taxonomy fields to return

   518 	 * @return array The prepared taxonomy data

   519 	 */

   520 	protected function _prepare_taxonomy( $taxonomy, $fields ) {

   521 		$_taxonomy = array(

   522 			'name' => $taxonomy->name,

   523 			'label' => $taxonomy->label,

   524 			'hierarchical' => (bool) $taxonomy->hierarchical,

   525 			'public' => (bool) $taxonomy->public,

   526 			'show_ui' => (bool) $taxonomy->show_ui,

   527 			'_builtin' => (bool) $taxonomy->_builtin,

   528 		);

   529 

   530 		if ( in_array( 'labels', $fields ) )

   531 			$_taxonomy['labels'] = (array) $taxonomy->labels;

   532 

   533 		if ( in_array( 'cap', $fields ) )

   534 			$_taxonomy['cap'] = (array) $taxonomy->cap;

   535 

   536 		if ( in_array( 'object_type', $fields ) )

   537 			$_taxonomy['object_type'] = array_unique( (array) $taxonomy->object_type );

   538 

   539 		return apply_filters( 'xmlrpc_prepare_taxonomy', $_taxonomy, $taxonomy, $fields );

   540 	}

   541 

   542 	/**

   543 	 * Prepares term data for return in an XML-RPC object.

   544 	 *

   545 	 * @access protected

   546 	 *

   547 	 * @param array|object $term The unprepared term data

   548 	 * @return array The prepared term data

   549 	 */

   550 	protected function _prepare_term( $term ) {

   551 		$_term = $term;

   552 		if ( ! is_array( $_term) )

   553 			$_term = get_object_vars( $_term );

   554 

   555 		// For Intergers which may be largeer than XMLRPC supports ensure we return strings.

   556 		$_term['term_id'] = strval( $_term['term_id'] );

   557 		$_term['term_group'] = strval( $_term['term_group'] );

   558 		$_term['term_taxonomy_id'] = strval( $_term['term_taxonomy_id'] );

   559 		$_term['parent'] = strval( $_term['parent'] );

   560 

   561 		// Count we are happy to return as an Integer because people really shouldn't use Terms that much.

   562 		$_term['count'] = intval( $_term['count'] );

   563 

   564 		return apply_filters( 'xmlrpc_prepare_term', $_term, $term );

   565 	}

   566 

   567 	/**

   568 	 * Convert a WordPress date string to an IXR_Date object.

   569 	 *

   570 	 * @access protected

   571 	 *

   572 	 * @param string $date

   573 	 * @return IXR_Date

   574 	 */

   575 	protected function _convert_date( $date ) {

   576 		if ( $date === '0000-00-00 00:00:00' ) {

   577 			return new IXR_Date( '00000000T00:00:00Z' );

   578 		}

   579 		return new IXR_Date( mysql2date( 'Ymd\TH:i:s', $date, false ) );

   580 	}

   581 

   582 	/**

   583 	 * Convert a WordPress GMT date string to an IXR_Date object.

   584 	 *

   585 	 * @access protected

   586 	 *

   587 	 * @param string $date_gmt

   588 	 * @param string $date

   589 	 * @return IXR_Date

   590 	 */

   591 	protected function _convert_date_gmt( $date_gmt, $date ) {

   592 		if ( $date !== '0000-00-00 00:00:00' && $date_gmt === '0000-00-00 00:00:00' ) {

   593 			return new IXR_Date( get_gmt_from_date( mysql2date( 'Y-m-d H:i:s', $date, false ), 'Ymd\TH:i:s' ) );

   594 		}

   595 		return $this->_convert_date( $date_gmt );

   596 	}

   597 

   598 	/**

   599 	 * Prepares post data for return in an XML-RPC object.

   600 	 *

   601 	 * @access protected

   602 	 *

   603 	 * @param array $post The unprepared post data

   604 	 * @param array $fields The subset of post type fields to return

   605 	 * @return array The prepared post data

   606 	 */

   607 	protected function _prepare_post( $post, $fields ) {

   608 		// holds the data for this post. built up based on $fields

   609 		$_post = array( 'post_id' => strval( $post['ID'] ) );

   610 

   611 		// prepare common post fields

   612 		$post_fields = array(

   613 			'post_title'        => $post['post_title'],

   614 			'post_date'         => $this->_convert_date( $post['post_date'] ),

   615 			'post_date_gmt'     => $this->_convert_date_gmt( $post['post_date_gmt'], $post['post_date'] ),

   616 			'post_modified'     => $this->_convert_date( $post['post_modified'] ),

   617 			'post_modified_gmt' => $this->_convert_date_gmt( $post['post_modified_gmt'], $post['post_modified'] ),

   618 			'post_status'       => $post['post_status'],

   619 			'post_type'         => $post['post_type'],

   620 			'post_name'         => $post['post_name'],

   621 			'post_author'       => $post['post_author'],

   622 			'post_password'     => $post['post_password'],

   623 			'post_excerpt'      => $post['post_excerpt'],

   624 			'post_content'      => $post['post_content'],

   625 			'post_parent'       => strval( $post['post_parent'] ),

   626 			'post_mime_type'    => $post['post_mime_type'],

   627 			'link'              => post_permalink( $post['ID'] ),

   628 			'guid'              => $post['guid'],

   629 			'menu_order'        => intval( $post['menu_order'] ),

   630 			'comment_status'    => $post['comment_status'],

   631 			'ping_status'       => $post['ping_status'],

   632 			'sticky'            => ( $post['post_type'] === 'post' && is_sticky( $post['ID'] ) ),

   633 		);

   634 

   635 		// Thumbnail

   636 		$post_fields['post_thumbnail'] = array();

   637 		$thumbnail_id = get_post_thumbnail_id( $post['ID'] );

   638 		if ( $thumbnail_id ) {

   639 			$thumbnail_size = current_theme_supports('post-thumbnail') ? 'post-thumbnail' : 'thumbnail';

   640 			$post_fields['post_thumbnail'] = $this->_prepare_media_item( get_post( $thumbnail_id ), $thumbnail_size );

   641 		}

   642 

   643 		// Consider future posts as published

   644 		if ( $post_fields['post_status'] === 'future' )

   645 			$post_fields['post_status'] = 'publish';

   646 

   647 		// Fill in blank post format

   648 		$post_fields['post_format'] = get_post_format( $post['ID'] );

   649 		if ( empty( $post_fields['post_format'] ) )

   650 			$post_fields['post_format'] = 'standard';

   651 

   652 		// Merge requested $post_fields fields into $_post

   653 		if ( in_array( 'post', $fields ) ) {

   654 			$_post = array_merge( $_post, $post_fields );

   655 		} else {

   656 			$requested_fields = array_intersect_key( $post_fields, array_flip( $fields ) );

   657 			$_post = array_merge( $_post, $requested_fields );

   658 		}

   659 

   660 		$all_taxonomy_fields = in_array( 'taxonomies', $fields );

   661 

   662 		if ( $all_taxonomy_fields || in_array( 'terms', $fields ) ) {

   663 			$post_type_taxonomies = get_object_taxonomies( $post['post_type'], 'names' );

   664 			$terms = wp_get_object_terms( $post['ID'], $post_type_taxonomies );

   665 			$_post['terms'] = array();

   666 			foreach ( $terms as $term ) {

   667 				$_post['terms'][] = $this->_prepare_term( $term );

   668 			}

   669 		}

   670 

   671 		if ( in_array( 'custom_fields', $fields ) )

   672 			$_post['custom_fields'] = $this->get_custom_fields( $post['ID'] );

   673 

   674 		if ( in_array( 'enclosure', $fields ) ) {

   675 			$_post['enclosure'] = array();

   676 			$enclosures = (array) get_post_meta( $post['ID'], 'enclosure' );

   677 			if ( ! empty( $enclosures ) ) {

   678 				$encdata = explode( "\n", $enclosures[0] );

   679 				$_post['enclosure']['url'] = trim( htmlspecialchars( $encdata[0] ) );

   680 				$_post['enclosure']['length'] = (int) trim( $encdata[1] );

   681 				$_post['enclosure']['type'] = trim( $encdata[2] );

   682 			}

   683 		}

   684 

   685 		return apply_filters( 'xmlrpc_prepare_post', $_post, $post, $fields );

   686 	}

   687 

   688 	/**

   689 	 * Prepares post data for return in an XML-RPC object.

   690 	 *

   691 	 * @access protected

   692 	 *

   693 	 * @param object $post_type Post type object

   694 	 * @param array $fields The subset of post fields to return

   695 	 * @return array The prepared post type data

   696 	 */

   697 	protected function _prepare_post_type( $post_type, $fields ) {

   698 		$_post_type = array(

   699 			'name' => $post_type->name,

   700 			'label' => $post_type->label,

   701 			'hierarchical' => (bool) $post_type->hierarchical,

   702 			'public' => (bool) $post_type->public,

   703 			'show_ui' => (bool) $post_type->show_ui,

   704 			'_builtin' => (bool) $post_type->_builtin,

   705 			'has_archive' => (bool) $post_type->has_archive,

   706 			'supports' => get_all_post_type_supports( $post_type->name ),

   707 		);

   708 

   709 		if ( in_array( 'labels', $fields ) ) {

   710 			$_post_type['labels'] = (array) $post_type->labels;

   711 		}

   712 

   713 		if ( in_array( 'cap', $fields ) ) {

   714 			$_post_type['cap'] = (array) $post_type->cap;

   715 			$_post_type['map_meta_cap'] = (bool) $post_type->map_meta_cap;

   716 		}

   717 

   718 		if ( in_array( 'menu', $fields ) ) {

   719 			$_post_type['menu_position'] = (int) $post_type->menu_position;

   720 			$_post_type['menu_icon'] = $post_type->menu_icon;

   721 			$_post_type['show_in_menu'] = (bool) $post_type->show_in_menu;

   722 		}

   723 

   724 		if ( in_array( 'taxonomies', $fields ) )

   725 			$_post_type['taxonomies'] = get_object_taxonomies( $post_type->name, 'names' );

   726 

   727 		return apply_filters( 'xmlrpc_prepare_post_type', $_post_type, $post_type );

   728 	}

   729 

   730 	/**

   731 	 * Prepares media item data for return in an XML-RPC object.

   732 	 *

   733 	 * @access protected

   734 	 *

   735 	 * @param object $media_item The unprepared media item data

   736 	 * @param string $thumbnail_size The image size to use for the thumbnail URL

   737 	 * @return array The prepared media item data

   738 	 */

   739 	protected function _prepare_media_item( $media_item, $thumbnail_size = 'thumbnail' ) {

   740 		$_media_item = array(

   741 			'attachment_id'    => strval( $media_item->ID ),

   742 			'date_created_gmt' => $this->_convert_date_gmt( $media_item->post_date_gmt, $media_item->post_date ),

   743 			'parent'           => $media_item->post_parent,

   744 			'link'             => wp_get_attachment_url( $media_item->ID ),

   745 			'title'            => $media_item->post_title,

   746 			'caption'          => $media_item->post_excerpt,

   747 			'description'      => $media_item->post_content,

   748 			'metadata'         => wp_get_attachment_metadata( $media_item->ID ),

   749 		);

   750 

   751 		$thumbnail_src = image_downsize( $media_item->ID, $thumbnail_size );

   752 		if ( $thumbnail_src )

   753 			$_media_item['thumbnail'] = $thumbnail_src[0];

   754 		else

   755 			$_media_item['thumbnail'] = $_media_item['link'];

   756 

   757 		return apply_filters( 'xmlrpc_prepare_media_item', $_media_item, $media_item, $thumbnail_size );

   758 	}

   759 

   760 	/**

   761 	 * Prepares page data for return in an XML-RPC object.

   762 	 *

   763 	 * @access protected

   764 	 *

   765 	 * @param object $page The unprepared page data

   766 	 * @return array The prepared page data

   767 	 */

   768 	protected function _prepare_page( $page ) {

   769 		// Get all of the page content and link.

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

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

   772 

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

   774 		$parent_title = "";

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

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

   777 			$parent_title = $parent->post_title;

   778 		}

   779 

   780 		// Determine comment and ping settings.

   781 		$allow_comments = comments_open( $page->ID ) ? 1 : 0;

   782 		$allow_pings = pings_open( $page->ID ) ? 1 : 0;

   783 

   784 		// Format page date.

   785 		$page_date = $this->_convert_date( $page->post_date );

   786 		$page_date_gmt = $this->_convert_date_gmt( $page->post_date_gmt, $page->post_date );

   787 

   788 		// Pull the categories info together.

   789 		$categories = array();

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

   791 			$categories[] = get_cat_name( $cat_id );

   792 		}

   793 

   794 		// Get the author info.

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

   796 

   797 		$page_template = get_page_template_slug( $page->ID );

   798 		if ( empty( $page_template ) )

   799 			$page_template = 'default';

   800 

   801 		$_page = array(

   802 			'dateCreated'            => $page_date,

   803 			'userid'                 => $page->post_author,

   804 			'page_id'                => $page->ID,

   805 			'page_status'            => $page->post_status,

   806 			'description'            => $full_page['main'],

   807 			'title'                  => $page->post_title,

   808 			'link'                   => $link,

   809 			'permaLink'              => $link,

   810 			'categories'             => $categories,

   811 			'excerpt'                => $page->post_excerpt,

   812 			'text_more'              => $full_page['extended'],

   813 			'mt_allow_comments'      => $allow_comments,

   814 			'mt_allow_pings'         => $allow_pings,

   815 			'wp_slug'                => $page->post_name,

   816 			'wp_password'            => $page->post_password,

   817 			'wp_author'              => $author->display_name,

   818 			'wp_page_parent_id'      => $page->post_parent,

   819 			'wp_page_parent_title'   => $parent_title,

   820 			'wp_page_order'          => $page->menu_order,

   821 			'wp_author_id'           => (string) $author->ID,

   822 			'wp_author_display_name' => $author->display_name,

   823 			'date_created_gmt'       => $page_date_gmt,

   824 			'custom_fields'          => $this->get_custom_fields( $page->ID ),

   825 			'wp_page_template'       => $page_template

   826 		);

   827 

   828 		return apply_filters( 'xmlrpc_prepare_page', $_page, $page );

   829 	}

   830 

   831 	/**

   832 	 * Prepares comment data for return in an XML-RPC object.

   833 	 *

   834 	 * @access protected

   835 	 *

   836 	 * @param object $comment The unprepared comment data

   837 	 * @return array The prepared comment data

   838 	 */

   839 	protected function _prepare_comment( $comment ) {

   840 		// Format page date.

   841 		$comment_date = $this->_convert_date( $comment->comment_date );

   842 		$comment_date_gmt = $this->_convert_date_gmt( $comment->comment_date_gmt, $comment->comment_date );

   843 

   844 		if ( '0' == $comment->comment_approved )

   845 			$comment_status = 'hold';

   846 		else if ( 'spam' == $comment->comment_approved )

   847 			$comment_status = 'spam';

   848 		else if ( '1' == $comment->comment_approved )

   849 			$comment_status = 'approve';

   850 		else

   851 			$comment_status = $comment->comment_approved;

   852 

   853 		$_comment = array(

   854 			'date_created_gmt' => $comment_date_gmt,

   855 			'user_id'          => $comment->user_id,

   856 			'comment_id'       => $comment->comment_ID,

   857 			'parent'           => $comment->comment_parent,

   858 			'status'           => $comment_status,

   859 			'content'          => $comment->comment_content,

   860 			'link'             => get_comment_link($comment),

   861 			'post_id'          => $comment->comment_post_ID,

   862 			'post_title'       => get_the_title($comment->comment_post_ID),

   863 			'author'           => $comment->comment_author,

   864 			'author_url'       => $comment->comment_author_url,

   865 			'author_email'     => $comment->comment_author_email,

   866 			'author_ip'        => $comment->comment_author_IP,

   867 			'type'             => $comment->comment_type,

   868 		);

   869 

   870 		return apply_filters( 'xmlrpc_prepare_comment', $_comment, $comment );

   871 	}

   872 

   873 	/**

   874 	 * Create a new post for any registered post type.

   875 	 *

   876 	 * @since 3.4.0

   877 	 *

   878 	 * @param array $args Method parameters. Contains:

   879 	 *  - int     $blog_id

   880 	 *  - string  $username

   881 	 *  - string  $password

   882 	 *  - array   $content_struct

   883 	 *      $content_struct can contain:

   884 	 *      - post_type (default: 'post')

   885 	 *      - post_status (default: 'draft')

   886 	 *      - post_title

   887 	 *      - post_author

   888 	 *      - post_exerpt

   889 	 *      - post_content

   890 	 *      - post_date_gmt | post_date

   891 	 *      - post_format

   892 	 *      - post_password

   893 	 *      - comment_status - can be 'open' | 'closed'

   894 	 *      - ping_status - can be 'open' | 'closed'

   895 	 *      - sticky

   896 	 *      - post_thumbnail - ID of a media item to use as the post thumbnail/featured image

   897 	 *      - custom_fields - array, with each element containing 'key' and 'value'

   898 	 *      - terms - array, with taxonomy names as keys and arrays of term IDs as values

   899 	 *      - terms_names - array, with taxonomy names as keys and arrays of term names as values

   900 	 *      - enclosure

   901 	 *      - any other fields supported by wp_insert_post()

   902 	 * @return string post_id

   903 	 */

   904 	function wp_newPost( $args ) {

   905 		if ( ! $this->minimum_args( $args, 4 ) )

   906 			return $this->error;

   907 

   908 		$this->escape( $args );

   909 

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

   911 		$username       = $args[1];

   912 		$password       = $args[2];

   913 		$content_struct = $args[3];

   914 

   915 		if ( ! $user = $this->login( $username, $password ) )

   916 			return $this->error;

   917 

   918 		do_action( 'xmlrpc_call', 'wp.newPost' );

   919 

   920 		unset( $content_struct['ID'] );

   921 

   922 		return $this->_insert_post( $user, $content_struct );

   923 	}

   924 

   925 	/**

   926 	 * Helper method for filtering out elements from an array.

   927 	 *

   928 	 * @since 3.4.0

   929 	 *

   930 	 * @param int $count Number to compare to one.

   931 	 */

   932 	private function _is_greater_than_one( $count ) {

   933 		return $count > 1;

   934 	}

   935 

   936 	/**

   937 	 * Helper method for wp_newPost and wp_editPost, containing shared logic.

   938 	 *

   939 	 * @since 3.4.0

   940 	 * @uses wp_insert_post()

   941 	 *

   942 	 * @param WP_User $user The post author if post_author isn't set in $content_struct.

   943 	 * @param array $content_struct Post data to insert.

   944 	 */

   945 	protected function _insert_post( $user, $content_struct ) {

   946 		$defaults = array( 'post_status' => 'draft', 'post_type' => 'post', 'post_author' => 0,

   947 			'post_password' => '', 'post_excerpt' => '', 'post_content' => '', 'post_title' => '' );

   948 

   949 		$post_data = wp_parse_args( $content_struct, $defaults );

   950 

   951 		$post_type = get_post_type_object( $post_data['post_type'] );

   952 		if ( ! $post_type )

   953 			return new IXR_Error( 403, __( 'Invalid post type' ) );

   954 

   955 		$update = ! empty( $post_data['ID'] );

   956 

   957 		if ( $update ) {

   958 			if ( ! get_post( $post_data['ID'] ) )

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

   960 			if ( ! current_user_can( $post_type->cap->edit_post, $post_data['ID'] ) )

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

   962 			if ( $post_data['post_type'] != get_post_type( $post_data['ID'] ) )

   963 				return new IXR_Error( 401, __( 'The post type may not be changed.' ) );

   964 		} else {

   965 			if ( ! current_user_can( $post_type->cap->edit_posts ) )

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

   967 		}

   968 

   969 		switch ( $post_data['post_status'] ) {

   970 			case 'draft':

   971 			case 'pending':

   972 				break;

   973 			case 'private':

   974 				if ( ! current_user_can( $post_type->cap->publish_posts ) )

   975 					return new IXR_Error( 401, __( 'Sorry, you are not allowed to create private posts in this post type' ) );

   976 				break;

   977 			case 'publish':

   978 			case 'future':

   979 				if ( ! current_user_can( $post_type->cap->publish_posts ) )

   980 					return new IXR_Error( 401, __( 'Sorry, you are not allowed to publish posts in this post type' ) );

   981 				break;

   982 			default:

   983 				$post_data['post_status'] = 'draft';

   984 			break;

   985 		}

   986 

   987 		if ( ! empty( $post_data['post_password'] ) && ! current_user_can( $post_type->cap->publish_posts ) )

   988 			return new IXR_Error( 401, __( 'Sorry, you are not allowed to create password protected posts in this post type' ) );

   989 

   990 		$post_data['post_author'] = absint( $post_data['post_author'] );

   991 		if ( ! empty( $post_data['post_author'] ) && $post_data['post_author'] != $user->ID ) {

   992 			if ( ! current_user_can( $post_type->cap->edit_others_posts ) )

   993 				return new IXR_Error( 401, __( 'You are not allowed to create posts as this user.' ) );

   994 

   995 			$author = get_userdata( $post_data['post_author'] );

   996 

   997 			if ( ! $author )

   998 				return new IXR_Error( 404, __( 'Invalid author ID.' ) );

   999 		} else {

  1000 			$post_data['post_author'] = $user->ID;

  1001 		}

  1002 

  1003 		if ( isset( $post_data['comment_status'] ) && $post_data['comment_status'] != 'open' && $post_data['comment_status'] != 'closed' )

  1004 			unset( $post_data['comment_status'] );

  1005 

  1006 		if ( isset( $post_data['ping_status'] ) && $post_data['ping_status'] != 'open' && $post_data['ping_status'] != 'closed' )

  1007 			unset( $post_data['ping_status'] );

  1008 

  1009 		// Do some timestamp voodoo

  1010 		if ( ! empty( $post_data['post_date_gmt'] ) ) {

  1011 			// We know this is supposed to be GMT, so we're going to slap that Z on there by force

  1012 			$dateCreated = rtrim( $post_data['post_date_gmt']->getIso(), 'Z' ) . 'Z';

  1013 		} elseif ( ! empty( $post_data['post_date'] ) ) {

  1014 			$dateCreated = $post_data['post_date']->getIso();

  1015 		}

  1016 

  1017 		if ( ! empty( $dateCreated ) ) {

  1018 			$post_data['post_date'] = get_date_from_gmt( iso8601_to_datetime( $dateCreated ) );

  1019 			$post_data['post_date_gmt'] = iso8601_to_datetime( $dateCreated, 'GMT' );

  1020 		}

  1021 

  1022 		if ( ! isset( $post_data['ID'] ) )

  1023 			$post_data['ID'] = get_default_post_to_edit( $post_data['post_type'], true )->ID;

  1024 		$post_ID = $post_data['ID'];

  1025 

  1026 		if ( $post_data['post_type'] == 'post' ) {

  1027 			// Private and password-protected posts cannot be stickied.

  1028 			if ( $post_data['post_status'] == 'private' || ! empty( $post_data['post_password'] ) ) {

  1029 				// Error if the client tried to stick the post, otherwise, silently unstick.

  1030 				if ( ! empty( $post_data['sticky'] ) )

  1031 					return new IXR_Error( 401, __( 'Sorry, you cannot stick a private post.' ) );

  1032 				if ( $update )

  1033 					unstick_post( $post_ID );

  1034 			} elseif ( isset( $post_data['sticky'] ) )  {

  1035 				if ( ! current_user_can( $post_type->cap->edit_others_posts ) )

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

  1037 				if ( $post_data['sticky'] )

  1038 					stick_post( $post_ID );

  1039 				else

  1040 					unstick_post( $post_ID );

  1041 			}

  1042 		}

  1043 

  1044 		if ( isset( $post_data['post_thumbnail'] ) ) {

  1045 			// empty value deletes, non-empty value adds/updates

  1046 			if ( ! $post_data['post_thumbnail'] )

  1047 				delete_post_thumbnail( $post_ID );

  1048 			elseif ( ! set_post_thumbnail( $post_ID, $post_data['post_thumbnail'] ) )

  1049 					return new IXR_Error( 404, __( 'Invalid attachment ID.' ) );

  1050 			unset( $content_struct['post_thumbnail'] );

  1051 		}

  1052 

  1053 		if ( isset( $post_data['custom_fields'] ) )

  1054 			$this->set_custom_fields( $post_ID, $post_data['custom_fields'] );

  1055 

  1056 		if ( isset( $post_data['terms'] ) || isset( $post_data['terms_names'] ) ) {

  1057 			$post_type_taxonomies = get_object_taxonomies( $post_data['post_type'], 'objects' );

  1058 

  1059 			// accumulate term IDs from terms and terms_names

  1060 			$terms = array();

  1061 

  1062 			// first validate the terms specified by ID

  1063 			if ( isset( $post_data['terms'] ) && is_array( $post_data['terms'] ) ) {

  1064 				$taxonomies = array_keys( $post_data['terms'] );

  1065 

  1066 				// validating term ids

  1067 				foreach ( $taxonomies as $taxonomy ) {

  1068 					if ( ! array_key_exists( $taxonomy , $post_type_taxonomies ) )

  1069 						return new IXR_Error( 401, __( 'Sorry, one of the given taxonomies is not supported by the post type.' ) );

  1070 

  1071 					if ( ! current_user_can( $post_type_taxonomies[$taxonomy]->cap->assign_terms ) )

  1072 						return new IXR_Error( 401, __( 'Sorry, you are not allowed to assign a term to one of the given taxonomies.' ) );

  1073 

  1074 					$term_ids = $post_data['terms'][$taxonomy];

  1075 					foreach ( $term_ids as $term_id ) {

  1076 						$term = get_term_by( 'id', $term_id, $taxonomy );

  1077 

  1078 						if ( ! $term )

  1079 							return new IXR_Error( 403, __( 'Invalid term ID' ) );

  1080 

  1081 						$terms[$taxonomy][] = (int) $term_id;

  1082 					}

  1083 				}

  1084 			}

  1085 

  1086 			// now validate terms specified by name

  1087 			if ( isset( $post_data['terms_names'] ) && is_array( $post_data['terms_names'] ) ) {

  1088 				$taxonomies = array_keys( $post_data['terms_names'] );

  1089 

  1090 				foreach ( $taxonomies as $taxonomy ) {

  1091 					if ( ! array_key_exists( $taxonomy , $post_type_taxonomies ) )

  1092 						return new IXR_Error( 401, __( 'Sorry, one of the given taxonomies is not supported by the post type.' ) );

  1093 

  1094 					if ( ! current_user_can( $post_type_taxonomies[$taxonomy]->cap->assign_terms ) )

  1095 						return new IXR_Error( 401, __( 'Sorry, you are not allowed to assign a term to one of the given taxonomies.' ) );

  1096 

  1097 					// for hierarchical taxonomies, we can't assign a term when multiple terms in the hierarchy share the same name

  1098 					$ambiguous_terms = array();

  1099 					if ( is_taxonomy_hierarchical( $taxonomy ) ) {

  1100 						$tax_term_names = get_terms( $taxonomy, array( 'fields' => 'names', 'hide_empty' => false ) );

  1101 

  1102 						// count the number of terms with the same name

  1103 						$tax_term_names_count = array_count_values( $tax_term_names );

  1104 

  1105 						// filter out non-ambiguous term names

  1106 						$ambiguous_tax_term_counts = array_filter( $tax_term_names_count, array( $this, '_is_greater_than_one') );

  1107 

  1108 						$ambiguous_terms = array_keys( $ambiguous_tax_term_counts );

  1109 					}

  1110 

  1111 					$term_names = $post_data['terms_names'][$taxonomy];

  1112 					foreach ( $term_names as $term_name ) {

  1113 						if ( in_array( $term_name, $ambiguous_terms ) )

  1114 							return new IXR_Error( 401, __( 'Ambiguous term name used in a hierarchical taxonomy. Please use term ID instead.' ) );

  1115 

  1116 						$term = get_term_by( 'name', $term_name, $taxonomy );

  1117 

  1118 						if ( ! $term ) {

  1119 							// term doesn't exist, so check that the user is allowed to create new terms

  1120 							if ( ! current_user_can( $post_type_taxonomies[$taxonomy]->cap->edit_terms ) )

  1121 								return new IXR_Error( 401, __( 'Sorry, you are not allowed to add a term to one of the given taxonomies.' ) );

  1122 

  1123 							// create the new term

  1124 							$term_info = wp_insert_term( $term_name, $taxonomy );

  1125 							if ( is_wp_error( $term_info ) )

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

  1127 

  1128 							$terms[$taxonomy][] = (int) $term_info['term_id'];

  1129 						} else {

  1130 							$terms[$taxonomy][] = (int) $term->term_id;

  1131 						}

  1132 					}

  1133 				}

  1134 			}

  1135