WordPress.org

Make WordPress Core

Changeset 25224


Ignore:
Timestamp:
09/04/2013 04:48:21 AM (5 years ago)
Author:
dd32
Message:

WP_HTTP: Replacing the Fsockopen & Streams Transports with a new Streams transport which fully supports HTTPS communication.
This changeset also bundles ca-bundle.crt from the Mozilla project to allow for us to verify SSL certificates on hosts which have an incomplete, outdated, or invalid local SSL configuration.
Props rmccue for major assistance getting this this far. See #25007 for discussion, also Fixes #16606

Location:
trunk
Files:
2 added
1 deleted
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/wp-includes/class-http.php

    r25222 r25224  
    8282            'decompress' => true,
    8383            'sslverify' => true,
     84            'sslcertificates' => ABSPATH . WPINC . '/certificates/ca-bundle.crt',
    8485            'stream' => false,
    8586            'filename' => null,
     
    215216     */
    216217    public function _get_first_available_transport( $args, $url = null ) {
    217         $request_order = apply_filters( 'http_api_transports', array( 'curl', 'streams', 'fsockopen' ), $args, $url );
     218        $request_order = apply_filters( 'http_api_transports', array(  'streams' ), $args, $url );
    218219
    219220        // Loop over each transport on each HTTP request looking for one which will serve this request's needs
     
    237238     * Also caches the transport instance to be used later.
    238239     *
    239      * The order for blocking requests is cURL, Streams, and finally Fsockopen.
    240      * The order for non-blocking requests is cURL, Streams and Fsockopen().
     240     * The order for requests is cURL, and then PHP Streams.
    241241     *
    242242     * @since 3.2.0
     
    633633        return wp_remote_request( $redirect_location, $args ); 
    634634    }
     635
     636    /**
     637     * Determines if a specified string represents an IP address or not.
     638     *
     639     * This function also detects the type of the IP address, returning either
     640     * '4' or '6' to represent a IPv4 and IPv6 address respectively.
     641     * This does not verify if the IP is a valid IP, only that it appears to be
     642     * an IP address.
     643     *
     644     * @see http://home.deds.nl/~aeron/regex/ for IPv6 regex
     645     *
     646     * @since 3.7.0
     647     * @static
     648     *
     649     * @param string $maybe_ip A suspected IP address
     650     * @return integer|bool Upon success, '4' or '6' to represent a IPv4 or IPv6 address, false upon failure
     651     */
     652    static function is_ip_address( $maybe_ip ) {
     653        if ( preg_match( '/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/', $maybe_ip ) )
     654            return 4;
     655
     656        if ( false !== strpos( $maybe_ip, ':' ) && preg_match( '/^(((?=.*(::))(?!.*\3.+\3))\3?|([\dA-F]{1,4}(\3|:\b|$)|\2))(?4){5}((?4){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4})$/i', trim( $maybe_ip, ' []' ) ) )
     657            return 6;
     658
     659        return false;
     660    }
     661
    635662}
    636663
    637664/**
    638  * HTTP request method uses fsockopen function to retrieve the url.
    639  *
    640  * This would be the preferred method, but the fsockopen implementation has the most overhead of all
    641  * the HTTP transport implementations.
     665 * HTTP request method uses PHP Streams to retrieve the url.
    642666 *
    643667 * @package WordPress
    644668 * @subpackage HTTP
    645  * @since 2.7.0
     669 * @since 3.7.0
    646670 */
    647 class WP_Http_Fsockopen {
    648     /**
    649      * Send a HTTP request to a URI using fsockopen().
    650      *
    651      * Does not support non-blocking mode.
     671class WP_Http_Streams {
     672    /**
     673     * Send a HTTP request to a URI using PHP Streams.
    652674     *
    653675     * @see WP_Http::request For default options descriptions.
    654676     *
    655      * @since 2.7
     677     * @since 3.7.0
    656678     * @access public
    657679     * @param string $url URI resource.
    658      * @param str|array $args Optional. Override the defaults.
     680     * @param string|array $args Optional. Override the defaults.
    659681     * @return array 'headers', 'body', 'response', 'cookies' and 'filename' keys.
    660682     */
     
    680702        WP_Http::buildCookieHeader( $r );
    681703
    682         $iError = null; // Store error number
    683         $strError = null; // Store error string
    684 
    685704        $arrURL = parse_url($url);
    686705
    687         $fsockopen_host = $arrURL['host'];
    688 
    689         $secure_transport = false;
    690 
     706        $connect_host = $arrURL['host'];
     707
     708        $secure_transport = ( $arrURL['scheme'] == 'ssl' || $arrURL['scheme'] == 'https' );
    691709        if ( ! isset( $arrURL['port'] ) ) {
    692             if ( ( $arrURL['scheme'] == 'ssl' || $arrURL['scheme'] == 'https' ) && extension_loaded('openssl') ) {
    693                 $fsockopen_host = "ssl://$fsockopen_host";
     710            if ( $arrURL['scheme'] == 'ssl' || $arrURL['scheme'] == 'https' ) {
    694711                $arrURL['port'] = 443;
    695712                $secure_transport = true;
     
    707724        }
    708725
    709         //fsockopen has issues with 'localhost' with IPv6 with certain versions of PHP, It attempts to connect to ::1,
     726        // Certain versions of PHP have issues with 'localhost' and IPv6, It attempts to connect to ::1,
    710727        // which fails when the server is not set up for it. For compatibility, always connect to the IPv4 address.
    711         if ( 'localhost' == strtolower($fsockopen_host) )
    712             $fsockopen_host = '127.0.0.1';
    713 
    714         // There are issues with the HTTPS and SSL protocols that cause errors that can be safely
    715         // ignored and should be ignored.
    716         if ( true === $secure_transport )
    717             $error_reporting = error_reporting(0);
    718 
    719         $startDelay = time();
     728        if ( 'localhost' == strtolower( $connect_host ) )
     729            $connect_host = '127.0.0.1';
     730
     731        $connect_host = $secure_transport ? 'ssl://' . $connect_host : 'tcp://' . $connect_host;
     732
     733        $is_local = isset( $r['local'] ) && $r['local'];
     734        $ssl_verify = isset( $r['sslverify'] ) && $r['sslverify'];
     735        if ( $is_local )
     736            $ssl_verify = apply_filters( 'https_local_ssl_verify', $ssl_verify );
     737        elseif ( ! $is_local )
     738            $ssl_verify = apply_filters( 'https_ssl_verify', $ssl_verify );
    720739
    721740        $proxy = new WP_HTTP_Proxy();
    722741
     742        $context = stream_context_create( array(
     743            'ssl' => array(
     744                'verify_peer' => $ssl_verify,
     745                //'CN_match' => $arrURL['host'], // This is handled by self::verify_ssl_certficate()
     746                'capture_peer_cert' => $ssl_verify,
     747                'SNI_enabled' => true,
     748                'cafile' => $r['sslcertificates'],
     749                'allow_self_signed' => ! $ssl_verify,
     750            )
     751        ) );
     752
     753        $timeout = (int) floor( $r['timeout'] );
     754        $utimeout = $timeout == $r['timeout'] ? 0 : 1000000 * $r['timeout'] % 1000000;
     755        $connect_timeout = max( $timeout, 1 );
     756
     757        $connection_error = null; // Store error number
     758        $connection_error_str = null; // Store error string
     759
    723760        if ( !WP_DEBUG ) {
     761            // In the event that the SSL connection fails, silence the many PHP Warnings
     762            if ( $secure_transport )
     763                $error_reporting = error_reporting(0);
     764
    724765            if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) )
    725                 $handle = @fsockopen( $proxy->host(), $proxy->port(), $iError, $strError, $r['timeout'] );
     766                $handle = @stream_socket_client( 'tcp://' . $proxy->host() . ':' . $proxy->port(), $connection_error, $connection_error_str, $connect_timeout, STREAM_CLIENT_CONNECT, $context );
    726767            else
    727                 $handle = @fsockopen( $fsockopen_host, $arrURL['port'], $iError, $strError, $r['timeout'] );
     768                $handle = @stream_socket_client( $connect_host . ':' . $arrURL['port'], $connection_error, $connection_error_str, $connect_timeout, STREAM_CLIENT_CONNECT, $context );
     769
     770            if ( $secure_transport )
     771                error_reporting( $error_reporting );
     772
    728773        } else {
    729774            if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) )
    730                 $handle = fsockopen( $proxy->host(), $proxy->port(), $iError, $strError, $r['timeout'] );
     775                $handle = stream_socket_client( 'tcp://' . $proxy->host() . ':' . $proxy->port(), $connection_error, $connection_error_str, $connect_timeout, STREAM_CLIENT_CONNECT, $context );
    731776            else
    732                 $handle = fsockopen( $fsockopen_host, $arrURL['port'], $iError, $strError, $r['timeout'] );
    733         }
    734 
    735         $endDelay = time();
    736 
    737         // If the delay is greater than the timeout then fsockopen shouldn't be used, because it will
    738         // cause a long delay.
    739         $elapseDelay = ($endDelay-$startDelay) > $r['timeout'];
    740         if ( true === $elapseDelay )
    741             add_option( 'disable_fsockopen', $endDelay, null, true );
    742 
    743         if ( false === $handle )
    744             return new WP_Error('http_request_failed', $iError . ': ' . $strError);
    745 
    746         $timeout = (int) floor( $r['timeout'] );
    747         $utimeout = $timeout == $r['timeout'] ? 0 : 1000000 * $r['timeout'] % 1000000;
     777                $handle = stream_socket_client( $connect_host . ':' . $arrURL['port'], $connection_error, $connection_error_str, $connect_timeout, STREAM_CLIENT_CONNECT, $context );
     778        }
     779
     780        if ( false === $handle ) {
     781            // SSL connection failed due to expired/invalid cert, or, OpenSSL configuration is broken
     782            if ( $secure_transport && 0 === $connection_error && '' === $connection_error_str )
     783                return new WP_Error( 'http_request_failed', __( 'The SSL Certificate for the host could not be verified.' ) );
     784
     785            return new WP_Error('http_request_failed', $connection_error . ': ' . $connection_error_str );
     786        }
     787
     788        // Verify that the SSL certificate is valid for this request
     789        if ( $secure_transport && $ssl_verify && ! $proxy->is_enabled() ) {
     790            if ( ! self::verify_ssl_certficate( $handle, $arrURL['host'] ) )
     791                return new WP_Error( 'http_request_failed', __( 'The SSL Certificate for the host could not be verified.' ) );
     792        }
     793
    748794        stream_set_timeout( $handle, $timeout, $utimeout );
    749795
     
    784830
    785831        if ( ! $r['blocking'] ) {
    786             fclose($handle);
     832            stream_set_blocking( $handle, 0 );
     833            fclose( $handle );
    787834            return array( 'headers' => array(), 'body' => '', 'response' => array('code' => false, 'message' => false), 'cookies' => array() );
    788835        }
     
    847894        fclose( $handle );
    848895
    849         if ( true === $secure_transport )
    850             error_reporting($error_reporting);
    851 
    852896        $arrHeaders = WP_Http::processHeaders( $process['headers'], $url );
    853897
     
    880924
    881925    /**
     926     * Verifies the received SSL certificate against it's Common Names and subjectAltName fields
     927     *
     928     * PHP's SSL verifications only verify that it's a valid Certificate, it doesn't verify if
     929     * the certificate is valid for the hostname which was requested.
     930     * This function verifies the requested hostname against certificate's subjectAltName field,
     931     * if that is empty, or contains no DNS entries, a fallback to the Common Name field is used.
     932     *
     933     * IP Address support is included if the request is being made to an IP address.
     934     *
     935     * @since 3.7.0
     936     * @static
     937     *
     938     * @param stream $stream The PHP Stream which the SSL request is being made over
     939     * @param string $host The hostname being requested
     940     * @return bool If the cerficiate presented in $stream is valid for $host
     941     */
     942    static function verify_ssl_certficate( $stream, $host ) {
     943        $context_options = stream_context_get_options( $stream );
     944
     945        if ( empty( $context_options['ssl']['peer_certificate'] ) )
     946            return false;
     947
     948        $cert = openssl_x509_parse( $context_options['ssl']['peer_certificate'] );
     949        if ( ! $cert )
     950            return false;
     951
     952        // If the request is being made to an IP address, we'll validate against IP fields in the cert (if they exist)
     953        $host_type = ( WP_HTTP::is_ip_address( $host ) ? 'ip' : 'dns' );
     954
     955        $certificate_hostnames = array();
     956        if ( ! empty( $cert['extensions']['subjectAltName'] ) ) {
     957            $match_against = preg_split( '/,\s*/', $cert['extensions']['subjectAltName'] );
     958            foreach ( $match_against as $match ) {
     959                list( $match_type, $match_host ) = explode( ':', $match );
     960                if ( $host_type == strtolower( trim( $match_type ) ) ) // IP: or DNS:
     961                    $certificate_hostnames[] = strtolower( trim( $match_host ) );
     962            }
     963        } elseif ( !empty( $cert['subject']['CN'] ) ) {
     964            // Only use the CN when the certificate includes no subjectAltName extension
     965            $certificate_hostnames[] = strtolower( $cert['subject']['CN'] );
     966        }
     967
     968        // Exact hostname/IP matches
     969        if ( in_array( strtolower( $host ), $certificate_hostnames ) )
     970            return true;
     971
     972        // IP's can't be wildcards, Stop processing
     973        if ( 'ip' == $host_type )
     974            return false;
     975
     976        // Test to see if the domain is at least 2 deep for wildcard support
     977        if ( substr_count( $host, '.' ) < 2 )
     978            return false;
     979
     980        // Wildcard subdomains certs (*.example.com) are valid for a.example.com but not a.b.example.com
     981        $wildcard_host = preg_replace( '/^[^.]+\./', '*.', $host );
     982
     983        return in_array( strtolower( $wildcard_host ), $certificate_hostnames );
     984    }
     985
     986    /**
    882987     * Whether this class can be used for retrieving an URL.
    883988     *
    884      * @since 2.7.0
    885989     * @static
     990     * @access public
     991     * @since 3.7.0
     992     *
    886993     * @return boolean False means this class can not be used, true means it can.
    887994     */
    888995    public static function test( $args = array() ) {
    889         if ( ! function_exists( 'fsockopen' ) )
     996        if ( ! function_exists( 'stream_socket_client' ) )
    890997            return false;
    891998
    892         if ( false !== ( $option = get_option( 'disable_fsockopen' ) ) && time() - $option < 12 * HOUR_IN_SECONDS )
    893             return false;
    894 
    895999        $is_ssl = isset( $args['ssl'] ) && $args['ssl'];
    8961000
    897         if ( $is_ssl && ! extension_loaded( 'openssl' ) )
    898             return false;
    899 
    900         return apply_filters( 'use_fsockopen_transport', true, $args );
     1001        if ( $is_ssl ) {
     1002            if ( ! extension_loaded( 'openssl' ) )
     1003                return false;
     1004            if ( ! function_exists( 'openssl_x509_parse' ) )
     1005                return false;
     1006        }
     1007
     1008        return apply_filters( 'use_streams_transport', true, $args );
    9011009    }
    9021010}
    9031011
    9041012/**
    905  * HTTP request method uses Streams to retrieve the url.
    906  *
    907  * Requires PHP 5.0+ and uses fopen with stream context. Requires that 'allow_url_fopen' PHP setting
    908  * to be enabled.
    909  *
    910  * Second preferred method for getting the URL, for PHP 5.
     1013 * Deprecated HTTP Transport method which used fsockopen.
     1014 * This class is not used, and is included for backwards compatibility only.
     1015 * All code should make use of WP_HTTP directly through it's API.
     1016 *
     1017 * @see WP_HTTP::request
     1018 *
     1019 * @package WordPress
     1020 * @subpackage HTTP
     1021 * @since 3.7.0
     1022 */
     1023class WP_HTTP_Fsockopen extends WP_HTTP_Streams {
     1024    // For backwards compatibility for users who are using the class directly
     1025}
     1026
     1027/**
     1028 * HTTP request method uses Curl extension to retrieve the url.
     1029 *
     1030 * Requires the Curl extension to be installed.
    9111031 *
    9121032 * @package WordPress
     
    9141034 * @since 2.7.0
    9151035 */
    916 class WP_Http_Streams {
    917     /**
    918      * Send a HTTP request to a URI using streams with fopen().
     1036class WP_Http_Curl {
     1037
     1038    /**
     1039     * Temporary header storage for during requests.
     1040     *
     1041     * @since 3.2.0
     1042     * @access private
     1043     * @var string
     1044     */
     1045    private $headers = '';
     1046
     1047    /**
     1048     * Temporary body storage for during requests.
     1049     *
     1050     * @since 3.6.0
     1051     * @access private
     1052     * @var string
     1053     */
     1054    private $body = '';
     1055
     1056    /**
     1057     * The maximum amount of data to recieve from the remote server
     1058     *
     1059     * @since 3.6.0
     1060     * @access private
     1061     * @var int
     1062     */
     1063    private $max_body_length = false;
     1064
     1065    /**
     1066     * The file resource used for streaming to file.
     1067     *
     1068     * @since 3.6.0
     1069     * @access private
     1070     * @var resource
     1071     */
     1072    private $stream_handle = false;
     1073
     1074    /**
     1075     * Send a HTTP request to a URI using cURL extension.
    9191076     *
    9201077     * @access public
     
    9431100        }
    9441101
    945         // Construct Cookie: header if any cookies are set
    946         WP_Http::buildCookieHeader( $r );
    947 
    948         $arrURL = parse_url($url);
    949 
    950         if ( false === $arrURL )
    951             return new WP_Error('http_request_failed', sprintf(__('Malformed URL: %s'), $url));
    952 
    953         if ( 'http' != $arrURL['scheme'] && 'https' != $arrURL['scheme'] )
    954             $url = preg_replace('|^' . preg_quote($arrURL['scheme'], '|') . '|', 'http', $url);
    955 
    956         // Convert Header array to string.
    957         $strHeaders = '';
    958         if ( is_array( $r['headers'] ) )
    959             foreach ( $r['headers'] as $name => $value )
    960                 $strHeaders .= "{$name}: $value\r\n";
    961         else if ( is_string( $r['headers'] ) )
    962             $strHeaders = $r['headers'];
    963 
    964         $is_local = isset($args['local']) && $args['local'];
    965         $ssl_verify = isset($args['sslverify']) && $args['sslverify'];
    966         if ( $is_local )
    967             $ssl_verify = apply_filters('https_local_ssl_verify', $ssl_verify);
    968         elseif ( ! $is_local )
    969             $ssl_verify = apply_filters('https_ssl_verify', $ssl_verify);
    970 
    971         $arrContext = array('http' =>
    972             array(
    973                 'method' => strtoupper($r['method']),
    974                 'user_agent' => $r['user-agent'],
    975                 'max_redirects' => 0, // Follow no redirects
    976                 'follow_redirects' => false,
    977                 'protocol_version' => (float) $r['httpversion'],
    978                 'header' => $strHeaders,
    979                 'ignore_errors' => true, // Return non-200 requests.
    980                 'timeout' => $r['timeout'],
    981                 'ssl' => array(
    982                         'verify_peer' => $ssl_verify,
    983                         'verify_host' => $ssl_verify
    984                 )
    985             )
    986         );
    987 
    988         $proxy = new WP_HTTP_Proxy();
    989 
    990         if ( $proxy->is_enabled() && $proxy->send_through_proxy( $url ) ) {
    991             $arrContext['http']['proxy'] = 'tcp://' . $proxy->host() . ':' . $proxy->port();
    992             $arrContext['http']['request_fulluri'] = true;
    993 
    994             // We only support Basic authentication so this will only work if that is what your proxy supports.
    995             if ( $proxy->use_authentication() )
    996                 $arrContext['http']['header'] .= $proxy->authentication_header() . "\r\n";
    997         }
    998 
    999         if ( ! is_null( $r['body'] ) )
    1000             $arrContext['http']['content'] = $r['body'];
    1001 
    1002         $context = stream_context_create($arrContext);
    1003 
    1004         if ( !WP_DEBUG )
    1005             $handle = @fopen($url, 'r', false, $context);
    1006         else
    1007             $handle = fopen($url, 'r', false, $context);
    1008 
    1009         if ( ! $handle )
    1010             return new WP_Error('http_request_failed', sprintf(__('Could not open handle for fopen() to %s'), $url));
    1011 
    1012         $timeout = (int) floor( $r['timeout'] );
    1013         $utimeout = $timeout == $r['timeout'] ? 0 : 1000000 * $r['timeout'] % 1000000;
    1014         stream_set_timeout( $handle, $timeout, $utimeout );
    1015 
    1016         if ( ! $r['blocking'] ) {
    1017             stream_set_blocking($handle, 0);
    1018             fclose($handle);
    1019             return array( 'headers' => array(), 'body' => '', 'response' => array('code' => false, 'message' => false), 'cookies' => array() );
    1020         }
    1021 
    1022         $max_bytes = isset( $r['limit_response_size'] ) ? intval( $r['limit_response_size'] ) : -1;
    1023         if ( $r['stream'] ) {
    1024             if ( ! WP_DEBUG )
    1025                 $stream_handle = @fopen( $r['filename'], 'w+' );
    1026             else
    1027                 $stream_handle = fopen( $r['filename'], 'w+' );
    1028 
    1029             if ( ! $stream_handle )
    1030                 return new WP_Error( 'http_request_failed', sprintf( __( 'Could not open handle for fopen() to %s' ), $r['filename'] ) );
    1031 
    1032             stream_copy_to_stream( $handle, $stream_handle, $max_bytes );
    1033 
    1034             fclose( $stream_handle );
    1035             $strResponse = '';
    1036         } else {
    1037             $strResponse = stream_get_contents( $handle, $max_bytes );
    1038         }
    1039 
    1040         $meta = stream_get_meta_data( $handle );
    1041 
    1042         fclose( $handle );
    1043 
    1044         $processedHeaders = array();
    1045         if ( isset( $meta['wrapper_data']['headers'] ) )
    1046             $processedHeaders = WP_Http::processHeaders( $meta['wrapper_data']['headers'], $url );
    1047         else
    1048             $processedHeaders = WP_Http::processHeaders( $meta['wrapper_data'], $url );
    1049 
    1050         $response = array(
    1051             'headers' => $processedHeaders['headers'],
    1052             'body' => null,
    1053             'response' => $processedHeaders['response'],
    1054             'cookies' => $processedHeaders['cookies'],
    1055             'filename' => $r['filename']
    1056         );
    1057 
    1058         // Handle redirects
    1059         if ( false !== ( $redirect_response = WP_HTTP::handle_redirects( $url, $r, $response ) ) )
    1060             return $redirect_response;
    1061 
    1062         if ( ! empty( $strResponse ) && isset( $processedHeaders['headers']['transfer-encoding'] ) && 'chunked' == $processedHeaders['headers']['transfer-encoding'] )
    1063             $strResponse = WP_Http::chunkTransferDecode($strResponse);
    1064 
    1065         if ( true === $r['decompress'] && true === WP_Http_Encoding::should_decode($processedHeaders['headers']) )
    1066             $strResponse = WP_Http_Encoding::decompress( $strResponse );
    1067 
    1068         $response['body'] = $strResponse;
    1069 
    1070         return $response;
    1071     }
    1072 
    1073     /**
    1074      * Whether this class can be used for retrieving an URL.
    1075      *
    1076      * @static
    1077      * @access public
    1078      * @since 2.7.0
    1079      *
    1080      * @return boolean False means this class can not be used, true means it can.
    1081      */
    1082     public static function test( $args = array() ) {
    1083         if ( ! function_exists( 'fopen' ) )
    1084             return false;
    1085 
    1086         if ( ! function_exists( 'ini_get' ) || true != ini_get( 'allow_url_fopen' ) )
    1087             return false;
    1088 
    1089         $is_ssl = isset( $args['ssl'] ) && $args['ssl'];
    1090 
    1091         if ( $is_ssl && ! extension_loaded( 'openssl' ) )
    1092             return false;
    1093 
    1094         return apply_filters( 'use_streams_transport', true, $args );
    1095     }
    1096 }
    1097 
    1098 /**
    1099  * HTTP request method uses Curl extension to retrieve the url.
    1100  *
    1101  * Requires the Curl extension to be installed.
    1102  *
    1103  * @package WordPress
    1104  * @subpackage HTTP
    1105  * @since 2.7
    1106  */
    1107 class WP_Http_Curl {
    1108 
    1109     /**
    1110      * Temporary header storage for during requests.
    1111      *
    1112      * @since 3.2.0
    1113      * @access private
    1114      * @var string
    1115      */
    1116     private $headers = '';
    1117 
    1118     /**
    1119      * Temporary body storage for during requests.
    1120      *
    1121      * @since 3.6.0
    1122      * @access private
    1123      * @var string
    1124      */
    1125     private $body = '';
    1126 
    1127     /**
    1128      * The maximum amount of data to recieve from the remote server
    1129      *
    1130      * @since 3.6.0
    1131      * @access private
    1132      * @var int
    1133      */
    1134     private $max_body_length = false;
    1135 
    1136     /**
    1137      * The file resource used for streaming to file.
    1138      *
    1139      * @since 3.6.0
    1140      * @access private
    1141      * @var resource
    1142      */
    1143     private $stream_handle = false;
    1144 
    1145     /**
    1146      * Send a HTTP request to a URI using cURL extension.
    1147      *
    1148      * @access public
    1149      * @since 2.7.0
    1150      *
    1151      * @param string $url
    1152      * @param str|array $args Optional. Override the defaults.
    1153      * @return array 'headers', 'body', 'response', 'cookies' and 'filename' keys.
    1154      */
    1155     function request($url, $args = array()) {
    1156         $defaults = array(
    1157             'method' => 'GET', 'timeout' => 5,
    1158             'redirection' => 5, 'httpversion' => '1.0',
    1159             'blocking' => true,
    1160             'headers' => array(), 'body' => null, 'cookies' => array()
    1161         );
    1162 
    1163         $r = wp_parse_args( $args, $defaults );
    1164 
    1165         if ( isset($r['headers']['User-Agent']) ) {
    1166             $r['user-agent'] = $r['headers']['User-Agent'];
    1167             unset($r['headers']['User-Agent']);
    1168         } else if ( isset($r['headers']['user-agent']) ) {
    1169             $r['user-agent'] = $r['headers']['user-agent'];
    1170             unset($r['headers']['user-agent']);
    1171         }
    1172 
    11731102        // Construct Cookie: header if any cookies are set.
    11741103        WP_Http::buildCookieHeader( $r );
     
    12081137        curl_setopt( $handle, CURLOPT_SSL_VERIFYHOST, ( $ssl_verify === true ) ? 2 : false );
    12091138        curl_setopt( $handle, CURLOPT_SSL_VERIFYPEER, $ssl_verify );
     1139        curl_setopt( $handle, CURLOPT_CAINFO, $r['sslcertificates'] );
    12101140        curl_setopt( $handle, CURLOPT_USERAGENT, $r['user-agent'] );
    12111141        // The option doesn't work with safe mode or when open_basedir is set, and there's a
  • trunk/tests/phpunit/tests/http/base.php

    r25046 r25224  
    271271        $this->assertEquals( 'PASS', wp_remote_retrieve_body( $res ) );
    272272    }
     273
     274    /**
     275     * Test if HTTPS support works
     276     *
     277     * @group ssl
     278     * @ticket 25007
     279     */
     280    function test_ssl() {
     281        if ( ! wp_http_supports( array( 'ssl' ) ) )
     282            $this->markTestSkipped( 'This install of PHP does not support SSL' );
     283
     284        $res = wp_remote_get( 'https://wordpress.org/' );
     285        $this->assertTrue( ! is_wp_error( $res ), print_r( $res, true ) );
     286    }
     287   
     288   
    273289}
Note: See TracChangeset for help on using the changeset viewer.