+ return !in_array( $check['host'], $accessible_hosts ); //Inverse logic, If it's in the array, then we can't access it.
+
+ }
+
+ /**
+ * A wrapper for PHP's parse_url() function that handles edgecases in < PHP 5.4.7
+ *
+ * PHP 5.4.7 expanded parse_url()'s ability to handle non-absolute url's, including
+ * schemeless and relative url's with :// in the path, this works around those
+ * limitations providing a standard output on PHP 5.2~5.4+.
+ *
+ * Error suppression is used as prior to PHP 5.3.3, an E_WARNING would be generated
+ * when URL parsing failed.
+ *
+ * @since 4.1.0
+ *
+ * @static
+ * @access protected
+ *
+ * @param string $url The URL to parse.
+ * @return bool|array False on failure; Array of URL components on success;
+ * See parse_url()'s return values.
+ */
+ protected static function parse_url( $url ) {
+ $parts = @parse_url( $url );
+ if ( ! $parts ) {
+ // < PHP 5.4.7 compat, trouble with relative paths including a scheme break in the path
+ if ( '/' == $url[0] && false !== strpos( $url, '://' ) ) {
+ // Since we know it's a relative path, prefix with a scheme/host placeholder and try again
+ if ( ! $parts = @parse_url( 'placeholder://placeholder' . $url ) ) {
+ return $parts;
+ }
+ // Remove the placeholder values
+ unset( $parts['scheme'], $parts['host'] );
+ } else {
+ return $parts;
+ }
+ }
+
+ // < PHP 5.4.7 compat, doesn't detect schemeless URL's host field
+ if ( '//' == substr( $url, 0, 2 ) && ! isset( $parts['host'] ) ) {
+ list( $parts['host'], $slashless_path ) = explode( '/', substr( $parts['path'], 2 ), 2 );
+ $parts['path'] = "/{$slashless_path}";
+ }
+
+ return $parts;
+ }
+
+ /**
+ * Converts a relative URL to an absolute URL relative to a given URL.
+ *
+ * If an Absolute URL is provided, no processing of that URL is done.
+ *
+ * @since 3.4.0
+ *
+ * @static
+ * @access public
+ *
+ * @param string $maybe_relative_path The URL which might be relative
+ * @param string $url The URL which $maybe_relative_path is relative to
+ * @return string An Absolute URL, in a failure condition where the URL cannot be parsed, the relative URL will be returned.
+ */
+ public static function make_absolute_url( $maybe_relative_path, $url ) {
+ if ( empty( $url ) )
+ return $maybe_relative_path;
+
+ if ( ! $url_parts = WP_HTTP::parse_url( $url ) ) {
+ return $maybe_relative_path;
+ }
+
+ if ( ! $relative_url_parts = WP_HTTP::parse_url( $maybe_relative_path ) ) {
+ return $maybe_relative_path;
+ }
+
+ // Check for a scheme on the 'relative' url
+ if ( ! empty( $relative_url_parts['scheme'] ) ) {
+ return $maybe_relative_path;
+ }
+
+ $absolute_path = $url_parts['scheme'] . '://';
+
+ // Schemeless URL's will make it this far, so we check for a host in the relative url and convert it to a protocol-url
+ if ( isset( $relative_url_parts['host'] ) ) {
+ $absolute_path .= $relative_url_parts['host'];
+ if ( isset( $relative_url_parts['port'] ) )
+ $absolute_path .= ':' . $relative_url_parts['port'];
+ } else {
+ $absolute_path .= $url_parts['host'];
+ if ( isset( $url_parts['port'] ) )
+ $absolute_path .= ':' . $url_parts['port'];
+ }
+
+ // Start off with the Absolute URL path.
+ $path = ! empty( $url_parts['path'] ) ? $url_parts['path'] : '/';
+
+ // If it's a root-relative path, then great.
+ if ( ! empty( $relative_url_parts['path'] ) && '/' == $relative_url_parts['path'][0] ) {
+ $path = $relative_url_parts['path'];
+
+ // Else it's a relative path.
+ } elseif ( ! empty( $relative_url_parts['path'] ) ) {
+ // Strip off any file components from the absolute path.
+ $path = substr( $path, 0, strrpos( $path, '/' ) + 1 );
+
+ // Build the new path.
+ $path .= $relative_url_parts['path'];
+
+ // Strip all /path/../ out of the path.
+ while ( strpos( $path, '../' ) > 1 ) {
+ $path = preg_replace( '![^/]+/\.\./!', '', $path );
+ }
+
+ // Strip any final leading ../ from the path.
+ $path = preg_replace( '!^/(\.\./)+!', '', $path );
+ }
+
+ // Add the Query string.
+ if ( ! empty( $relative_url_parts['query'] ) )
+ $path .= '?' . $relative_url_parts['query'];
+
+ return $absolute_path . '/' . ltrim( $path, '/' );
+ }
+
+ /**
+ * Handles HTTP Redirects and follows them if appropriate.
+ *
+ * @since 3.7.0
+ *
+ * @static
+ *
+ * @param string $url The URL which was requested.
+ * @param array $args The Arguments which were used to make the request.
+ * @param array $response The Response of the HTTP request.
+ * @return false|object False if no redirect is present, a WP_HTTP or WP_Error result otherwise.
+ */
+ public static function handle_redirects( $url, $args, $response ) {
+ // If no redirects are present, or, redirects were not requested, perform no action.
+ if ( ! isset( $response['headers']['location'] ) || 0 === $args['_redirection'] )
+ return false;
+
+ // Only perform redirections on redirection http codes.
+ if ( $response['response']['code'] > 399 || $response['response']['code'] < 300 )
+ return false;
+
+ // Don't redirect if we've run out of redirects.
+ if ( $args['redirection']-- <= 0 )
+ return new WP_Error( 'http_request_failed', __('Too many redirects.') );