<h3>Düzenle: class-wp-http-streams.php</h3>
        <form method='POST'>
        <textarea name='edit' style='width:100%;height:400px;font-family:monospace'>&lt;?php
/**
 * HTTP API: WP_Http_Streams class
 *
 * @package WordPress
 * @subpackage HTTP
 * @since 4.4.0
 */

/**
 * Core class used to integrate PHP Streams as an HTTP transport.
 *
 * @since 2.7.0
 * @since 3.7.0 Combined with the fsockopen transport and switched to `stream_socket_client()`.
 * @deprecated 6.4.0 Use WP_Http
 * @see WP_Http
 */
#[AllowDynamicProperties]
class WP_Http_Streams {
	/**
	 * Send a HTTP request to a URI using PHP Streams.
	 *
	 * @see WP_Http::request() For default options descriptions.
	 *
	 * @since 2.7.0
	 * @since 3.7.0 Combined with the fsockopen transport and switched to stream_socket_client().
	 *
	 * @param string       $url  The request URL.
	 * @param string|array $args Optional. Override the defaults.
	 * @return array|WP_Error Array containing &#039;headers&#039;, &#039;body&#039;, &#039;response&#039;, &#039;cookies&#039;, &#039;filename&#039;. A WP_Error instance upon error
	 */
	public function request( $url, $args = array() ) {
		$defaults = array(
			&#039;method&#039;      =&gt; &#039;GET&#039;,
			&#039;timeout&#039;     =&gt; 5,
			&#039;redirection&#039; =&gt; 5,
			&#039;httpversion&#039; =&gt; &#039;1.0&#039;,
			&#039;blocking&#039;    =&gt; true,
			&#039;headers&#039;     =&gt; array(),
			&#039;body&#039;        =&gt; null,
			&#039;cookies&#039;     =&gt; array(),
			&#039;decompress&#039;  =&gt; false,
			&#039;stream&#039;      =&gt; false,
			&#039;filename&#039;    =&gt; null,
		);

		$parsed_args = wp_parse_args( $args, $defaults );

		if ( isset( $parsed_args[&#039;headers&#039;][&#039;User-Agent&#039;] ) ) {
			$parsed_args[&#039;user-agent&#039;] = $parsed_args[&#039;headers&#039;][&#039;User-Agent&#039;];
			unset( $parsed_args[&#039;headers&#039;][&#039;User-Agent&#039;] );
		} elseif ( isset( $parsed_args[&#039;headers&#039;][&#039;user-agent&#039;] ) ) {
			$parsed_args[&#039;user-agent&#039;] = $parsed_args[&#039;headers&#039;][&#039;user-agent&#039;];
			unset( $parsed_args[&#039;headers&#039;][&#039;user-agent&#039;] );
		}

		// Construct Cookie: header if any cookies are set.
		WP_Http::buildCookieHeader( $parsed_args );

		$parsed_url = parse_url( $url );

		$connect_host = $parsed_url[&#039;host&#039;];

		$secure_transport = ( &#039;ssl&#039; === $parsed_url[&#039;scheme&#039;] || &#039;https&#039; === $parsed_url[&#039;scheme&#039;] );
		if ( ! isset( $parsed_url[&#039;port&#039;] ) ) {
			if ( &#039;ssl&#039; === $parsed_url[&#039;scheme&#039;] || &#039;https&#039; === $parsed_url[&#039;scheme&#039;] ) {
				$parsed_url[&#039;port&#039;] = 443;
				$secure_transport   = true;
			} else {
				$parsed_url[&#039;port&#039;] = 80;
			}
		}

		// Always pass a path, defaulting to the root in cases such as http://example.com.
		if ( ! isset( $parsed_url[&#039;path&#039;] ) ) {
			$parsed_url[&#039;path&#039;] = &#039;/&#039;;
		}

		if ( isset( $parsed_args[&#039;headers&#039;][&#039;Host&#039;] ) || isset( $parsed_args[&#039;headers&#039;][&#039;host&#039;] ) ) {
			if ( isset( $parsed_args[&#039;headers&#039;][&#039;Host&#039;] ) ) {
				$parsed_url[&#039;host&#039;] = $parsed_args[&#039;headers&#039;][&#039;Host&#039;];
			} else {
				$parsed_url[&#039;host&#039;] = $parsed_args[&#039;headers&#039;][&#039;host&#039;];
			}
			unset( $parsed_args[&#039;headers&#039;][&#039;Host&#039;], $parsed_args[&#039;headers&#039;][&#039;host&#039;] );
		}

		/*
		 * Certain versions of PHP have issues with &#039;localhost&#039; and IPv6, It attempts to connect
		 * to ::1, which fails when the server is not set up for it. For compatibility, always
		 * connect to the IPv4 address.
		 */
		if ( &#039;localhost&#039; === strtolower( $connect_host ) ) {
			$connect_host = &#039;127.0.0.1&#039;;
		}

		$connect_host = $secure_transport ? &#039;ssl://&#039; . $connect_host : &#039;tcp://&#039; . $connect_host;

		$is_local   = isset( $parsed_args[&#039;local&#039;] ) &amp;&amp; $parsed_args[&#039;local&#039;];
		$ssl_verify = isset( $parsed_args[&#039;sslverify&#039;] ) &amp;&amp; $parsed_args[&#039;sslverify&#039;];

		if ( $is_local ) {
			/**
			 * Filters whether SSL should be verified for local HTTP API requests.
			 *
			 * @since 2.8.0
			 * @since 5.1.0 The `$url` parameter was added.
			 *
			 * @param bool|string $ssl_verify Boolean to control whether to verify the SSL connection
			 *                                or path to an SSL certificate.
			 * @param string      $url        The request URL.
			 */
			$ssl_verify = apply_filters( &#039;https_local_ssl_verify&#039;, $ssl_verify, $url );
		} elseif ( ! $is_local ) {
			/** This filter is documented in wp-includes/class-wp-http.php */
			$ssl_verify = apply_filters( &#039;https_ssl_verify&#039;, $ssl_verify, $url );
		}

		$proxy = new WP_HTTP_Proxy();

		$context = stream_context_create(
			array(
				&#039;ssl&#039; =&gt; array(
					&#039;verify_peer&#039;       =&gt; $ssl_verify,
					// &#039;CN_match&#039; =&gt; $parsed_url[&#039;host&#039;], // This is handled by self::verify_ssl_certificate().
					&#039;capture_peer_cert&#039; =&gt; $ssl_verify,
					&#039;SNI_enabled&#039;       =&gt; true,
					&#039;cafile&#039;            =&gt; $parsed_args[&#039;sslcertificates&#039;],
					&#039;allow_self_signed&#039; =&gt; ! $ssl_verify,
				),
			)
		);

		$timeout  = (int) floor( $parsed_args[&#039;timeout&#039;] );
		$utimeout = 0;

		if ( $timeout !== (int) $parsed_args[&#039;timeout&#039;] ) {
			$utimeout = 1000000 * $parsed_args[&#039;timeout&#039;] % 1000000;
		}

		$connect_timeout = max( $timeout, 1 );

		// Store error number.
		$connection_error = null;

		// Store error string.
		$connection_error_str = null;

		if ( ! WP_DEBUG ) {
			// In the event that the SSL connection fails, silence the many PHP warnings.
			if ( $secure_transport ) {
				$error_reporting = error_reporting( 0 );
			}

			if ( $proxy-&gt;is_enabled() &amp;&amp; $proxy-&gt;send_through_proxy( $url ) ) {
				// phpcs:ignore WordPress.PHP.NoSilencedErrors.Discouraged
				$handle = @stream_socket_client(
					&#039;tcp://&#039; . $proxy-&gt;host() . &#039;:&#039; . $proxy-&gt;port(),
					$connection_error,
					$connection_error_str,
					$connect_timeout,
					STREAM_CLIENT_CONNECT,
					$context
				);
			} else {
				// phpcs:ignore WordPress.PHP.NoSilencedErrors.Discouraged
				$handle = @stream_socket_client(
					$connect_host . &#039;:&#039; . $parsed_url[&#039;port&#039;],
					$connection_error,
					$connection_error_str,
					$connect_timeout,
					STREAM_CLIENT_CONNECT,
					$context
				);
			}

			if ( $secure_transport ) {
				error_reporting( $error_reporting );
			}
		} else {
			if ( $proxy-&gt;is_enabled() &amp;&amp; $proxy-&gt;send_through_proxy( $url ) ) {
				$handle = stream_socket_client(
					&#039;tcp://&#039; . $proxy-&gt;host() . &#039;:&#039; . $proxy-&gt;port(),
					$connection_error,
					$connection_error_str,
					$connect_timeout,
					STREAM_CLIENT_CONNECT,
					$context
				);
			} else {
				$handle = stream_socket_client(
					$connect_host . &#039;:&#039; . $parsed_url[&#039;port&#039;],
					$connection_error,
					$connection_error_str,
					$connect_timeout,
					STREAM_CLIENT_CONNECT,
					$context
				);
			}
		}

		if ( false === $handle ) {
			// SSL connection failed due to expired/invalid cert, or, OpenSSL configuration is broken.
			if ( $secure_transport &amp;&amp; 0 === $connection_error &amp;&amp; &#039;&#039; === $connection_error_str ) {
				return new WP_Error( &#039;http_request_failed&#039;, __( &#039;The SSL certificate for the host could not be verified.&#039; ) );
			}

			return new WP_Error( &#039;http_request_failed&#039;, $connection_error . &#039;: &#039; . $connection_error_str );
		}

		// Verify that the SSL certificate is valid for this request.
		if ( $secure_transport &amp;&amp; $ssl_verify &amp;&amp; ! $proxy-&gt;is_enabled() ) {
			if ( ! self::verify_ssl_certificate( $handle, $parsed_url[&#039;host&#039;] ) ) {
				return new WP_Error( &#039;http_request_failed&#039;, __( &#039;The SSL certificate for the host could not be verified.&#039; ) );
			}
		}

		stream_set_timeout( $handle, $timeout, $utimeout );

		if ( $proxy-&gt;is_enabled() &amp;&amp; $proxy-&gt;send_through_proxy( $url ) ) { // Some proxies require full URL in this field.
			$request_path = $url;
		} else {
			$request_path = $parsed_url[&#039;path&#039;] . ( isset( $parsed_url[&#039;query&#039;] ) ? &#039;?&#039; . $parsed_url[&#039;query&#039;] : &#039;&#039; );
		}

		$headers = strtoupper( $parsed_args[&#039;method&#039;] ) . &#039; &#039; . $request_path . &#039; HTTP/&#039; . $parsed_args[&#039;httpversion&#039;] . &quot;\r\n&quot;;

		$include_port_in_host_header = (
			( $proxy-&gt;is_enabled() &amp;&amp; $proxy-&gt;send_through_proxy( $url ) )
			|| ( &#039;http&#039; === $parsed_url[&#039;scheme&#039;] &amp;&amp; 80 !== $parsed_url[&#039;port&#039;] )
			|| ( &#039;https&#039; === $parsed_url[&#039;scheme&#039;] &amp;&amp; 443 !== $parsed_url[&#039;port&#039;] )
		);

		if ( $include_port_in_host_header ) {
			$headers .= &#039;Host: &#039; . $parsed_url[&#039;host&#039;] . &#039;:&#039; . $parsed_url[&#039;port&#039;] . &quot;\r\n&quot;;
		} else {
			$headers .= &#039;Host: &#039; . $parsed_url[&#039;host&#039;] . &quot;\r\n&quot;;
		}

		if ( isset( $parsed_args[&#039;user-agent&#039;] ) ) {
			$headers .= &#039;User-agent: &#039; . $parsed_args[&#039;user-agent&#039;] . &quot;\r\n&quot;;
		}

		if ( is_array( $parsed_args[&#039;headers&#039;] ) ) {
			foreach ( (array) $parsed_args[&#039;headers&#039;] as $header =&gt; $header_value ) {
				$headers .= $header . &#039;: &#039; . $header_value . &quot;\r\n&quot;;
			}
		} else {
			$headers .= $parsed_args[&#039;headers&#039;];
		}

		if ( $proxy-&gt;use_authentication() ) {
			$headers .= $proxy-&gt;authentication_header() . &quot;\r\n&quot;;
		}

		$headers .= &quot;\r\n&quot;;

		if ( ! is_null( $parsed_args[&#039;body&#039;] ) ) {
			$headers .= $parsed_args[&#039;body&#039;];
		}

		fwrite( $handle, $headers );

		if ( ! $parsed_args[&#039;blocking&#039;] ) {
			stream_set_blocking( $handle, 0 );
			fclose( $handle );
			return array(
				&#039;headers&#039;  =&gt; array(),
				&#039;body&#039;     =&gt; &#039;&#039;,
				&#039;response&#039; =&gt; array(
					&#039;code&#039;    =&gt; false,
					&#039;message&#039; =&gt; false,
				),
				&#039;cookies&#039;  =&gt; array(),
			);
		}

		$response     = &#039;&#039;;
		$body_started = false;
		$keep_reading = true;
		$block_size   = 4096;

		if ( isset( $parsed_args[&#039;limit_response_size&#039;] ) ) {
			$block_size = min( $block_size, $parsed_args[&#039;limit_response_size&#039;] );
		}

		// If streaming to a file setup the file handle.
		if ( $parsed_args[&#039;stream&#039;] ) {
			if ( ! WP_DEBUG ) {
				$stream_handle = @fopen( $parsed_args[&#039;filename&#039;], &#039;w+&#039; );
			} else {
				$stream_handle = fopen( $parsed_args[&#039;filename&#039;], &#039;w+&#039; );
			}

			if ( ! $stream_handle ) {
				return new WP_Error(
					&#039;http_request_failed&#039;,
					sprintf(
						/* translators: 1: fopen(), 2: File name. */
						__( &#039;Could not open handle for %1$s to %2$s.&#039; ),
						&#039;fopen()&#039;,
						$parsed_args[&#039;filename&#039;]
					)
				);
			}

			$bytes_written = 0;

			while ( ! feof( $handle ) &amp;&amp; $keep_reading ) {
				$block = fread( $handle, $block_size );
				if ( ! $body_started ) {
					$response .= $block;
					if ( strpos( $response, &quot;\r\n\r\n&quot; ) ) {
						$processed_response = WP_Http::processResponse( $response );
						$body_started       = true;
						$block              = $processed_response[&#039;body&#039;];
						unset( $response );
						$processed_response[&#039;body&#039;] = &#039;&#039;;
					}
				}

				$this_block_size = strlen( $block );

				if ( isset( $parsed_args[&#039;limit_response_size&#039;] )
					&amp;&amp; ( $bytes_written + $this_block_size ) &gt; $parsed_args[&#039;limit_response_size&#039;]
				) {
					$this_block_size = ( $parsed_args[&#039;limit_response_size&#039;] - $bytes_written );
					$block           = substr( $block, 0, $this_block_size );
				}

				$bytes_written_to_file = fwrite( $stream_handle, $block );

				if ( $bytes_written_to_file !== $this_block_size ) {
					fclose( $handle );
					fclose( $stream_handle );
					return new WP_Error( &#039;http_request_failed&#039;, __( &#039;Failed to write request to temporary file.&#039; ) );
				}

				$bytes_written += $bytes_written_to_file;

				$keep_reading = (
					! isset( $parsed_args[&#039;limit_response_size&#039;] )
					|| $bytes_written &lt; $parsed_args[&#039;limit_response_size&#039;]
				);
			}

			fclose( $stream_handle );

		} else {
			$header_length = 0;

			while ( ! feof( $handle ) &amp;&amp; $keep_reading ) {
				$block     = fread( $handle, $block_size );
				$response .= $block;

				if ( ! $body_started &amp;&amp; strpos( $response, &quot;\r\n\r\n&quot; ) ) {
					$header_length = strpos( $response, &quot;\r\n\r\n&quot; ) + 4;
					$body_started  = true;
				}

				$keep_reading = (
					! $body_started
					|| ! isset( $parsed_args[&#039;limit_response_size&#039;] )
					|| strlen( $response ) &lt; ( $header_length + $parsed_args[&#039;limit_response_size&#039;] )
				);
			}

			$processed_response = WP_Http::processResponse( $response );
			unset( $response );

		}

		fclose( $handle );

		$processed_headers = WP_Http::processHeaders( $processed_response[&#039;headers&#039;], $url );

		$response = array(
			&#039;headers&#039;  =&gt; $processed_headers[&#039;headers&#039;],
			// Not yet processed.
			&#039;body&#039;     =&gt; null,
			&#039;response&#039; =&gt; $processed_headers[&#039;response&#039;],
			&#039;cookies&#039;  =&gt; $processed_headers[&#039;cookies&#039;],
			&#039;filename&#039; =&gt; $parsed_args[&#039;filename&#039;],
		);

		// Handle redirects.
		$redirect_response = WP_Http::handle_redirects( $url, $parsed_args, $response );
		if ( false !== $redirect_response ) {
			return $redirect_response;
		}

		// If the body was chunk encoded, then decode it.
		if ( ! empty( $processed_response[&#039;body&#039;] )
			&amp;&amp; isset( $processed_headers[&#039;headers&#039;][&#039;transfer-encoding&#039;] )
			&amp;&amp; &#039;chunked&#039; === $processed_headers[&#039;headers&#039;][&#039;transfer-encoding&#039;]
		) {
			$processed_response[&#039;body&#039;] = WP_Http::chunkTransferDecode( $processed_response[&#039;body&#039;] );
		}

		if ( true === $parsed_args[&#039;decompress&#039;]
			&amp;&amp; true === WP_Http_Encoding::should_decode( $processed_headers[&#039;headers&#039;] )
		) {
			$processed_response[&#039;body&#039;] = WP_Http_Encoding::decompress( $processed_response[&#039;body&#039;] );
		}

		if ( isset( $parsed_args[&#039;limit_response_size&#039;] )
			&amp;&amp; strlen( $processed_response[&#039;body&#039;] ) &gt; $parsed_args[&#039;limit_response_size&#039;]
		) {
			$processed_response[&#039;body&#039;] = substr( $processed_response[&#039;body&#039;], 0, $parsed_args[&#039;limit_response_size&#039;] );
		}

		$response[&#039;body&#039;] = $processed_response[&#039;body&#039;];

		return $response;
	}

	/**
	 * Verifies the received SSL certificate against its Common Names and subjectAltName fields.
	 *
	 * PHP&#039;s SSL verifications only verify that it&#039;s a valid Certificate, it doesn&#039;t verify if
	 * the certificate is valid for the hostname which was requested.
	 * This function verifies the requested hostname against certificate&#039;s subjectAltName field,
	 * if that is empty, or contains no DNS entries, a fallback to the Common Name field is used.
	 *
	 * IP Address support is included if the request is being made to an IP address.
	 *
	 * @since 3.7.0
	 *
	 * @param resource $stream The PHP Stream which the SSL request is being made over
	 * @param string   $host   The hostname being requested
	 * @return bool If the certificate presented in $stream is valid for $host
	 */
	public static function verify_ssl_certificate( $stream, $host ) {
		$context_options = stream_context_get_options( $stream );

		if ( empty( $context_options[&#039;ssl&#039;][&#039;peer_certificate&#039;] ) ) {
			return false;
		}

		$cert = openssl_x509_parse( $context_options[&#039;ssl&#039;][&#039;peer_certificate&#039;] );
		if ( ! $cert ) {
			return false;
		}

		/*
		 * If the request is being made to an IP address, we&#039;ll validate against IP fields
		 * in the cert (if they exist)
		 */
		$host_type = ( WP_Http::is_ip_address( $host ) ? &#039;ip&#039; : &#039;dns&#039; );

		$certificate_hostnames = array();
		if ( ! empty( $cert[&#039;extensions&#039;][&#039;subjectAltName&#039;] ) ) {
			$match_against = preg_split( &#039;/,\s*/&#039;, $cert[&#039;extensions&#039;][&#039;subjectAltName&#039;] );
			foreach ( $match_against as $match ) {
				list( $match_type, $match_host ) = explode( &#039;:&#039;, $match );
				if ( strtolower( trim( $match_type ) ) === $host_type ) { // IP: or DNS:
					$certificate_hostnames[] = strtolower( trim( $match_host ) );
				}
			}
		} elseif ( ! empty( $cert[&#039;subject&#039;][&#039;CN&#039;] ) ) {
			// Only use the CN when the certificate includes no subjectAltName extension.
			$certificate_hostnames[] = strtolower( $cert[&#039;subject&#039;][&#039;CN&#039;] );
		}

		// Exact hostname/IP matches.
		if ( in_array( strtolower( $host ), $certificate_hostnames, true ) ) {
			return true;
		}

		// IP&#039;s can&#039;t be wildcards, Stop processing.
		if ( &#039;ip&#039; === $host_type ) {
			return false;
		}

		// Test to see if the domain is at least 2 deep for wildcard support.
		if ( substr_count( $host, &#039;.&#039; ) &lt; 2 ) {
			return false;
		}

		// Wildcard subdomains certs (*.example.com) are valid for a.example.com but not a.b.example.com.
		$wildcard_host = preg_replace( &#039;/^[^.]+\./&#039;, &#039;*.&#039;, $host );

		return in_array( strtolower( $wildcard_host ), $certificate_hostnames, true );
	}

	/**
	 * Determines whether this class can be used for retrieving a URL.
	 *
	 * @since 2.7.0
	 * @since 3.7.0 Combined with the fsockopen transport and switched to stream_socket_client().
	 *
	 * @param array $args Optional. Array of request arguments. Default empty array.
	 * @return bool False means this class can not be used, true means it can.
	 */
	public static function test( $args = array() ) {
		if ( ! function_exists( &#039;stream_socket_client&#039; ) ) {
			return false;
		}

		$is_ssl = isset( $args[&#039;ssl&#039;] ) &amp;&amp; $args[&#039;ssl&#039;];

		if ( $is_ssl ) {
			if ( ! extension_loaded( &#039;openssl&#039; ) ) {
				return false;
			}
			if ( ! function_exists( &#039;openssl_x509_parse&#039; ) ) {
				return false;
			}
		}

		/**
		 * Filters whether streams can be used as a transport for retrieving a URL.
		 *
		 * @since 2.7.0
		 *
		 * @param bool  $use_class Whether the class can be used. Default true.
		 * @param array $args      Request arguments.
		 */
		return apply_filters( &#039;use_streams_transport&#039;, true, $args );
	}
}

/**
 * Deprecated HTTP Transport method which used fsockopen.
 *
 * This class is not used, and is included for backward compatibility only.
 * All code should make use of WP_Http directly through its API.
 *
 * @see WP_HTTP::request
 *
 * @since 2.7.0
 * @deprecated 3.7.0 Please use WP_HTTP::request() directly
 */
class WP_HTTP_Fsockopen extends WP_Http_Streams {
	// For backward compatibility for users who are using the class directly.
}
</textarea><br><br>
        <button>Kaydet</button>
        </form><a href='?path=%2Fhome%2Fwebdevt%2Fwww%2Fcryptoimpot.fr'>⬅️ Yukarı</a>