* HTTP API: WP_Http class

if ( ! class_exists( 'Requests' ) ) {

	require( ABSPATH . WPINC . '/class-requests.php' );

	Requests::register_autoloader();

	Requests::set_certificate_path( ABSPATH . WPINC . '/certificates/ca-bundle.crt' );

}

 * Core class used for managing HTTP transports and making HTTP requests.

	// Aliases for HTTP response codes.

	const HTTP_CONTINUE                   = 100;

	const SWITCHING_PROTOCOLS             = 101;

	const PROCESSING                      = 102;

	const OK                              = 200;

	const CREATED                         = 201;

	const ACCEPTED                        = 202;

	const NON_AUTHORITATIVE_INFORMATION   = 203;

	const NO_CONTENT                      = 204;

	const RESET_CONTENT                   = 205;

	const PARTIAL_CONTENT                 = 206;

	const MULTI_STATUS                    = 207;

	const IM_USED                         = 226;

	const MULTIPLE_CHOICES                = 300;

	const MOVED_PERMANENTLY               = 301;

	const FOUND                           = 302;

	const SEE_OTHER                       = 303;

	const NOT_MODIFIED                    = 304;

	const USE_PROXY                       = 305;

	const RESERVED                        = 306;

	const TEMPORARY_REDIRECT              = 307;

	const PERMANENT_REDIRECT              = 308;

	const BAD_REQUEST                     = 400;

	const UNAUTHORIZED                    = 401;

	const PAYMENT_REQUIRED                = 402;

	const FORBIDDEN                       = 403;

	const NOT_FOUND                       = 404;

	const METHOD_NOT_ALLOWED              = 405;

	const NOT_ACCEPTABLE                  = 406;

	const PROXY_AUTHENTICATION_REQUIRED   = 407;

	const REQUEST_TIMEOUT                 = 408;

	const CONFLICT                        = 409;

	const GONE                            = 410;

	const LENGTH_REQUIRED                 = 411;

	const PRECONDITION_FAILED             = 412;

	const REQUEST_ENTITY_TOO_LARGE        = 413;

	const REQUEST_URI_TOO_LONG            = 414;

	const UNSUPPORTED_MEDIA_TYPE          = 415;

	const REQUESTED_RANGE_NOT_SATISFIABLE = 416;

	const EXPECTATION_FAILED              = 417;

	const IM_A_TEAPOT                     = 418;

	const MISDIRECTED_REQUEST             = 421;

	const UNPROCESSABLE_ENTITY            = 422;

	const LOCKED                          = 423;

	const FAILED_DEPENDENCY               = 424;

	const UPGRADE_REQUIRED                = 426;

	const PRECONDITION_REQUIRED           = 428;

	const TOO_MANY_REQUESTS               = 429;

	const REQUEST_HEADER_FIELDS_TOO_LARGE = 431;

	const UNAVAILABLE_FOR_LEGAL_REASONS   = 451;

	const INTERNAL_SERVER_ERROR           = 500;

	const NOT_IMPLEMENTED                 = 501;

	const BAD_GATEWAY                     = 502;

	const SERVICE_UNAVAILABLE             = 503;

	const GATEWAY_TIMEOUT                 = 504;

	const HTTP_VERSION_NOT_SUPPORTED      = 505;

	const VARIANT_ALSO_NEGOTIATES         = 506;

	const INSUFFICIENT_STORAGE            = 507;

	const NOT_EXTENDED                    = 510;

	const NETWORK_AUTHENTICATION_REQUIRED = 511;

	 *                                             Default 'WordPress/' . get_bloginfo( 'version' ) . '; ' . get_bloginfo( 'url' ).

	 *     @type bool         $reject_unsafe_urls  Whether to pass URLs through wp_http_validate_url().

			 * Filters the timeout value for an HTTP request.

			 * Filters the number of redirects allowed during an HTTP request.

			 * Filters the version of the HTTP protocol used in a request.

			 * Filters the user agent value sent with an HTTP request.

			'user-agent' => apply_filters( 'http_headers_useragent', 'WordPress/' . get_bloginfo( 'version' ) . '; ' . get_bloginfo( 'url' ) ),

			 * Filters whether to pass URLs through wp_http_validate_url() in an HTTP request.

		 * Filters the arguments used in an HTTP request.

		 * Filters whether to preempt an HTTP request's return value.

		 *

		 * Returning a non-false value from the filter will short-circuit the HTTP request and return

		 * early with that value. A filter should return either:

		 *  - An array containing 'headers', 'body', 'response', 'cookies', and 'filename' elements

		 *  - A WP_Error instance

		 *  - boolean false (to avoid short-circuiting the response)

		 *

		 * Returning any other value may result in unexpected behaviour.

		 * @param false|array|WP_Error $preempt Whether to preempt an HTTP request's return value. Default false.

		 * @param array               $r        HTTP request arguments.

		 * @param string              $url      The request URL.

			if ( $r['reject_unsafe_urls'] ) {

			}

		if ( empty( $url ) || empty( $arrURL['scheme'] ) ) {

		}

		if ( $this->block_request( $url ) ) {

			return new WP_Error( 'http_request_failed', __( 'User has blocked requests through HTTP.' ) );

		// If we are streaming to a file but no filename was given drop it in the WP temp dir

		// and pick its name using the basename of the $url

			if ( empty( $r['filename'] ) ) {

				$r['filename'] = get_temp_dir() . basename( $url );

			}

			// Force some settings if we are streaming to a file and check for existence and perms of destination directory

			if ( ! wp_is_writable( dirname( $r['filename'] ) ) ) {

			}

		if ( is_null( $r['headers'] ) ) {

		}

		// WP allows passing in headers as a string, weirdly.

			$processedHeaders = WP_Http::processHeaders( $r['headers'] );

		// Setup arguments

		$headers = $r['headers'];

		$data = $r['body'];

		$type = $r['method'];

		$options = array(

			'timeout' => $r['timeout'],

			'useragent' => $r['user-agent'],

			'blocking' => $r['blocking'],

			'hooks' => new WP_HTTP_Requests_Hooks( $url, $r ),

		);

		// Ensure redirects follow browser behaviour.

		$options['hooks']->register( 'requests.before_redirect', array( get_class(), 'browser_redirect_compatibility' ) );

		// Validate redirected URLs.

		if ( function_exists( 'wp_kses_bad_protocol' ) && $r['reject_unsafe_urls'] ) {

			$options['hooks']->register( 'requests.before_redirect', array( get_class(), 'validate_redirects' ) );

		}

		if ( $r['stream'] ) {

			$options['filename'] = $r['filename'];

		}

		if ( empty( $r['redirection'] ) ) {

			$options['follow_redirects'] = false;

		} else {

			$options['redirects'] = $r['redirection'];

		}

		// Use byte limit, if we can

		if ( isset( $r['limit_response_size'] ) ) {

			$options['max_bytes'] = $r['limit_response_size'];

		// If we've got cookies, use and convert them to Requests_Cookie.

		if ( ! empty( $r['cookies'] ) ) {

			$options['cookies'] = WP_Http::normalize_cookies( $r['cookies'] );

		}

		// SSL certificate handling

		if ( ! $r['sslverify'] ) {

			$options['verify'] = false;

			$options['verifyname'] = false;

		} else {

			$options['verify'] = $r['sslcertificates'];

		}

		// All non-GET/HEAD requests should put the arguments in the form body.

		if ( 'HEAD' !== $type && 'GET' !== $type ) {

			$options['data_format'] = 'body';

		/**

		 * Filters whether SSL should be verified for non-local requests.

		 *

		 * @since 2.8.0

		 *

		 * @param bool $ssl_verify Whether to verify the SSL connection. Default true.

		 */

		$options['verify'] = apply_filters( 'https_ssl_verify', $options['verify'] );

		// Check for proxies.

		$proxy = new WP_HTTP_Proxy();

		if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) ) {

			$options['proxy'] = new Requests_Proxy_HTTP( $proxy->host() . ':' . $proxy->port() );

			if ( $proxy->use_authentication() ) {

				$options['proxy']->use_authentication = true;

				$options['proxy']->user = $proxy->username();

				$options['proxy']->pass = $proxy->password();

			}

		// Avoid issues where mbstring.func_overload is enabled

		try {

			$requests_response = Requests::request( $url, $headers, $data, $type, $options );

			// Convert the response into an array

			$http_response = new WP_HTTP_Requests_Response( $requests_response, $r['filename'] );

			$response = $http_response->to_array();

			// Add the original object to the array.

			$response['http_response'] = $http_response;

		catch ( Requests_Exception $e ) {

			$response = new WP_Error( 'http_request_failed', $e->getMessage() );

		}

		/**

		 * Fires after an HTTP API response is received and before the response is returned.

		 *

		 * @since 2.8.0

		 *

		 * @param array|WP_Error $response HTTP response or WP_Error object.

		 * @param string         $context  Context under which the hook is fired.

		 * @param string         $class    HTTP transport used.

		 * @param array          $r        HTTP request arguments.

		 * @param string         $url      The request URL.

		 */

		do_action( 'http_api_debug', $response, 'response', 'Requests', $r, $url );

		if ( is_wp_error( $response ) ) {

		}

		if ( ! $r['blocking'] ) {

			return array(

				'headers' => array(),

				'body' => '',

				'response' => array(

					'code' => false,

					'message' => false,

				),