wreq 1.2.10 → 1.2.12

data/src/lib.rs

@@ -15,6 +15,7 @@ mod http;
 mod options;
 mod rt;
 mod serde;
+mod tls;
 
 use magnus::{Error, Module, Ruby, Value};
 
@@ -85,6 +86,7 @@ pub fn patch(ruby: &Ruby, args: &[Value]) -> Result<Response, magnus::Error> {
 fn init(ruby: &Ruby) -> Result<(), Error> {
     let gem_module = ruby.define_module(RUBY_MODULE_NAME)?;
     gem_module.const_set("VERSION", VERSION)?;
+    error::include(ruby, &gem_module)?;
     gem_module.define_module_function("request", magnus::function!(request, -1))?;
     gem_module.define_module_function("get", magnus::function!(get, -1))?;
     gem_module.define_module_function("post", magnus::function!(post, -1))?;
@@ -97,8 +99,10 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     http::include(ruby, &gem_module)?;
     header::include(ruby, &gem_module)?;
     cookie::include(ruby, &gem_module)?;
+    tls::include(ruby, &gem_module)?;
     client::include(ruby, &gem_module)?;
     emulate::include(ruby, &gem_module)?;
-    error::include(ruby, &gem_module)?;
+    #[cfg(unix)]
+    rt::initialize(ruby)?;
     Ok(())
 }

data/src/macros.rs

@@ -148,11 +148,11 @@ macro_rules! define_ruby_enum {
 }
 
 macro_rules! extract_request {
-    ($args:expr, $required:ty) => {{
+    ($ruby:expr, $args:expr, $required:ty) => {{
+        crate::rt::ensure_current($ruby)?;
         let args = magnus::scan_args::scan_args::<$required, (), (), (), magnus::RHash, ()>($args)?;
         let required = args.required;
-        let ruby = magnus::Ruby::get_with(args.keywords);
-        let request = crate::client::req::Request::new(&ruby, args.keywords)?;
+        let request = crate::client::req::Request::new($ruby, args.keywords)?;
         (required, request)
     }};
 }

data/src/rt.rs

@@ -1,26 +1,57 @@
-use std::sync::LazyLock;
+use std::{io, sync::OnceLock};
 
 use magnus::Ruby;
-use tokio::runtime::{Builder, Runtime};
+use tokio::runtime::{Builder, Runtime as TokioRuntime};
 
 use crate::{
     error::{interrupt_error, runtime_initialization_error},
     gvl,
 };
 
-/// Initialize the global runtime lazily and preserve failures for Ruby.
-static RUNTIME: LazyLock<Result<Runtime, std::io::Error>> = LazyLock::new(|| {
-    let mut builder = Builder::new_multi_thread();
+#[cfg(unix)]
+use crate::{
+    arch,
+    error::{fork_error, fork_handler_error},
+};
 
-    builder.enable_all().build()
-});
+/// Initialize the global runtime lazily and preserve failures for Ruby.
+static RUNTIME: OnceLock<Result<TokioRuntime, io::Error>> = OnceLock::new();
 
 enum BlockOnError<E> {
     Interrupted,
     Future(E),
 }
 
-/// Block on a future to completion on the global Tokio runtime.
+/// Register fork tracking while the native extension is being loaded.
+///
+/// # Errors
+///
+/// Returns `Wreq::ForkError` if the platform cannot install its child-process
+/// callback.
+#[cfg(unix)]
+pub fn initialize(ruby: &Ruby) -> Result<(), magnus::Error> {
+    arch::initialize_fork_tracking().map_err(|err| fork_handler_error(ruby, &err))
+}
+
+/// Reject a child process that inherited the loaded native extension.
+///
+/// # Errors
+///
+/// Returns `Wreq::ForkError` when the extension was loaded before the current
+/// process was forked.
+pub fn ensure_current(ruby: &Ruby) -> Result<(), magnus::Error> {
+    #[cfg(unix)]
+    if let Some((owner_pid, current_pid)) = arch::forked_process_ids() {
+        return Err(fork_error(ruby, owner_pid, current_pid));
+    }
+
+    #[cfg(not(unix))]
+    let _ = ruby;
+
+    Ok(())
+}
+
+/// Block on a future to completion on the current process's global Tokio runtime.
 ///
 /// The future runs without Ruby's GVL, so it must not construct Ruby objects or
 /// Ruby exceptions. Convert Rust errors back into Ruby errors after the GVL has
@@ -28,7 +59,8 @@ enum BlockOnError<E> {
 ///
 /// # Errors
 ///
-/// Returns `Wreq::BuilderError` if the Tokio runtime cannot be initialized,
+/// Returns `Wreq::ForkError` if the extension belongs to a parent process,
+/// `Wreq::BuilderError` if the Tokio runtime cannot be initialized,
 /// `Wreq::InterruptError` if Ruby interrupts the request, or the error produced
 /// by `map_err` if the future fails.
 pub fn try_block_on<F, T, E, M>(ruby: &Ruby, future: F, map_err: M) -> Result<T, magnus::Error>
@@ -36,7 +68,12 @@ where
     F: Future<Output = Result<T, E>>,
     M: FnOnce(&Ruby, E) -> magnus::Error,
 {
+    ensure_current(ruby)?;
     let runtime = RUNTIME
+        .get_or_init(|| {
+            let mut builder = Builder::new_multi_thread();
+            builder.enable_all().build()
+        })
         .as_ref()
         .map_err(|err| runtime_initialization_error(ruby, err))?;
     let result = gvl::nogvl_cancellable(|flag| {

data/src/tls.rs

@@ -0,0 +1,51 @@
+//! Ruby wrappers for TLS metadata attached to a response.
+//!
+//! Certificates use the DER encoding described by the X.509 profile in
+//! [RFC 5280 section 4.1](https://www.rfc-editor.org/rfc/rfc5280#section-4.1).
+
+use magnus::{Error, Module, RArray, RModule, RString, Ruby, value::ReprValue};
+
+/// Read-only Ruby wrapper around [`wreq::tls::TlsInfo`].
+///
+/// The native value keeps certificate bytes alive independently of the response
+/// body. Its `Bytes` buffers are cheap to clone, while accessors copy the data
+/// into Ruby-owned Strings so callers cannot mutate the stored metadata.
+#[derive(Clone)]
+#[magnus::wrap(class = "Wreq::TlsInfo", free_immediately, size)]
+pub(crate) struct TlsInfo(pub(crate) wreq::tls::TlsInfo);
+
+impl TlsInfo {
+    /// Copy the DER-encoded leaf certificate into a binary Ruby String.
+    fn peer_certificate(ruby: &Ruby, rb_self: &Self) -> Option<RString> {
+        rb_self
+            .0
+            .peer_certificate()
+            .map(|der| ruby.str_from_slice(der))
+    }
+
+    /// Copy the certificate chain into a frozen Array of binary Ruby Strings.
+    ///
+    /// Only the Array is frozen. Its Strings are independent copies and remain
+    /// mutable in Ruby.
+    fn peer_certificate_chain(ruby: &Ruby, rb_self: &Self) -> Option<RArray> {
+        rb_self.0.peer_certificate_chain().map(|chain| {
+            let certificates = ruby.ary_from_iter(chain.map(|cert| ruby.str_from_slice(cert)));
+            certificates.freeze();
+            certificates
+        })
+    }
+}
+
+/// Define the `Wreq::TlsInfo` Ruby class and its readers.
+pub(crate) fn include(ruby: &Ruby, gem_module: &RModule) -> Result<(), Error> {
+    let tls_info_class = gem_module.define_class("TlsInfo", ruby.class_object())?;
+    tls_info_class.define_method(
+        "peer_certificate",
+        magnus::method!(TlsInfo::peer_certificate, 0),
+    )?;
+    tls_info_class.define_method(
+        "peer_certificate_chain",
+        magnus::method!(TlsInfo::peer_certificate_chain, 0),
+    )?;
+    Ok(())
+}

data/test/fork_test.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "rbconfig"
+require "tempfile"
+require "timeout"
+
+class ForkTest < Minitest::Test
+  FORK_ERROR_LABELS = %w[
+    before_runtime
+    invalid_client
+    invalid_request
+    fresh_body_sender
+    inherited_body_sender_push
+    inherited_body_sender_close
+    inherited_body_sender_closed
+    fresh_client
+    inherited_client
+    inherited_response
+    inherited_response_text
+    inherited_response_chunks
+    inherited_response_close
+  ].freeze
+
+  def test_fork_error_is_a_runtime_error
+    assert_operator Wreq::ForkError, :<, RuntimeError
+  end
+
+  def test_loaded_extension_is_rejected_after_fork
+    skip "fork is not supported on this platform" unless Process.respond_to?(:fork)
+
+    stdout, stderr, status = run_fork_script("fork_safety.rb")
+
+    assert status.success?, "subprocess failed with #{status.inspect}: #{stderr}"
+    assert_equal "ok\n", stdout
+    FORK_ERROR_LABELS.each do |label|
+      assert_match(/#{label}=Wreq::ForkError:.*cannot be used after fork/, stderr)
+      assert_match(/#{label}_retry=Wreq::ForkError:.*cannot be used after fork/, stderr)
+    end
+    assert_match(/inherited_gc=ok/, stderr)
+    refute_match(/\[BUG\]|segmentation fault|panicked/i, stderr)
+  end
+
+  private
+
+  def run_fork_script(name)
+    lib_dir = File.expand_path("../lib", __dir__)
+    script = File.expand_path("scripts/#{name}", __dir__)
+
+    Tempfile.create("wreq-fork-stdout") do |stdout|
+      Tempfile.create("wreq-fork-stderr") do |stderr|
+        pid = Process.spawn(
+          RbConfig.ruby,
+          "-I",
+          lib_dir,
+          script,
+          out: stdout,
+          err: stderr,
+          pgroup: true
+        )
+        status = Timeout.timeout(30) { Process.wait2(pid).last }
+        stdout.rewind
+        stderr.rewind
+        return [stdout.read, stderr.read, status]
+      rescue Timeout::Error
+        begin
+          Process.kill("KILL", -pid)
+        rescue Errno::ESRCH
+          nil
+        end
+
+        begin
+          Process.wait(pid)
+        rescue Errno::ECHILD
+          nil
+        end
+
+        flunk "#{name} timed out"
+      end
+    end
+  end
+end

data/test/scripts/fork_safety.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "socket"
+require "timeout"
+require "weakref"
+require "wreq"
+
+$stdout.sync = true
+$stderr.sync = true
+
+def expect_fork_error(label)
+  child_pid = fork do
+    2.times do |attempt|
+      attempt_label = attempt.zero? ? label : "#{label}_retry"
+
+      begin
+        Timeout.timeout(5) { yield }
+      rescue Wreq::ForkError => error
+        warn "#{attempt_label}=#{error.class}: #{error.message}"
+        next
+      rescue => error
+        warn "#{attempt_label}=unexpected #{error.class}: #{error.message}"
+        exit! 2
+      end
+
+      warn "#{attempt_label}=missing Wreq::ForkError"
+      exit! 3
+    end
+
+    exit! 0
+  end
+
+  _, status = Process.wait2(child_pid)
+  abort "#{label} child failed with #{status.inspect}" unless status.success?
+end
+
+expect_fork_error("before_runtime") { Wreq::Client.new }
+expect_fork_error("invalid_client") { Wreq::Client.new(unknown: true) }
+expect_fork_error("invalid_request") { Wreq.get(1) }
+expect_fork_error("fresh_body_sender") { Wreq::BodySender.new(0) }
+
+server = TCPServer.new("127.0.0.1", 0)
+port = server.addr[1]
+server_pid = fork do
+  3.times do
+    ready = IO.select([server], nil, nil, 10)
+    exit! 4 unless ready
+
+    socket = server.accept
+    begin
+      while (line = socket.gets)
+        break if line == "\r\n"
+      end
+      socket.write("HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok")
+    ensure
+      socket.close
+    end
+  end
+  exit! 0
+ensure
+  server.close
+end
+server.close
+
+url = "http://127.0.0.1:#{port}/"
+client = Wreq::Client.new
+abort "parent warm-up failed" unless client.get(url).bytes == "ok"
+
+def build_inherited_objects(client, url)
+  [Wreq::Client.new, Wreq::BodySender.new, client.get(url)]
+end
+
+inherited_objects = build_inherited_objects(client, url)
+inherited_weak_refs = inherited_objects.map { |object| WeakRef.new(object) }
+
+expect_fork_error("inherited_body_sender_push") do
+  inherited_objects[1].push("chunk")
+end
+expect_fork_error("inherited_body_sender_close") { inherited_objects[1].close }
+expect_fork_error("inherited_body_sender_closed") { inherited_objects[1].closed? }
+expect_fork_error("fresh_client") { Wreq::Client.new }
+expect_fork_error("inherited_client") { client.get(url) }
+expect_fork_error("inherited_response") { inherited_objects[2].bytes }
+expect_fork_error("inherited_response_text") { inherited_objects[2].text(1) }
+expect_fork_error("inherited_response_chunks") { inherited_objects[2].chunks }
+expect_fork_error("inherited_response_close") { inherited_objects[2].close }
+
+# Release the earlier test blocks so this array is the only strong reference.
+GC.start(full_mark: true, immediate_sweep: true)
+gc_pid = fork do
+  inherited_objects = nil
+  3.times { GC.start(full_mark: true, immediate_sweep: true) }
+  alive = inherited_weak_refs.each_index.select do |index|
+    inherited_weak_refs[index].weakref_alive?
+  end
+  abort "inherited objects were not collected: #{alive.join(", ")}" unless alive.empty?
+  warn "inherited_gc=ok"
+  exit! 0
+rescue => error
+  warn "inherited_gc=unexpected #{error.class}: #{error.message}"
+  exit! 5
+end
+_, gc_status = Process.wait2(gc_pid)
+abort "inherited GC child failed with #{gc_status.inspect}" unless gc_status.success?
+
+abort "parent request after fork failed" unless client.get(url).bytes == "ok"
+_, server_status = Process.wait2(server_pid)
+abort "server failed with #{server_status.inspect}" unless server_status.success?
+
+puts "ok"

data/test/support/tls_server.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "socket"
+require "timeout"
+
+# A small HTTPS server that serves every expected request on one TLS connection.
+module TlsTestServer
+  RESPONSE_BODY = "ok"
+
+  module_function
+
+  def with_connection(request_count:)
+    tcp_server = TCPServer.new("127.0.0.1", 0)
+    context, certificate_der = server_context
+    ssl_server = OpenSSL::SSL::SSLServer.new(tcp_server, context)
+    outcome = Queue.new
+    server_thread = Thread.new do
+      socket = ssl_server.accept
+      request_lines = []
+
+      request_count.times do |index|
+        request_lines << read_request(socket)
+        connection = (index == request_count - 1) ? "close" : "keep-alive"
+        socket.write(response(connection))
+        socket.flush
+      end
+
+      outcome << {connections: 1, requests: request_lines}
+    rescue => error
+      outcome << error
+    ensure
+      socket&.close
+    end
+    server_thread.report_on_exception = false
+
+    yield "https://127.0.0.1:#{tcp_server.addr[1]}/", certificate_der
+
+    result = Timeout.timeout(5) { outcome.pop }
+    raise result if result.is_a?(StandardError)
+
+    result
+  ensure
+    tcp_server&.close
+    server_thread&.join(5)
+    if server_thread&.alive?
+      server_thread.kill
+      server_thread.join
+    end
+  end
+
+  def read_request(socket)
+    request_line = socket.gets
+    raise EOFError, "client closed before sending a request" unless request_line
+
+    loop do
+      line = socket.gets
+      raise EOFError, "client closed while sending headers" unless line
+      break if line == "\r\n"
+    end
+
+    request_line
+  end
+  private_class_method :read_request
+
+  def response(connection)
+    [
+      "HTTP/1.1 200 OK",
+      "Content-Length: #{RESPONSE_BODY.bytesize}",
+      "Connection: #{connection}",
+      "",
+      RESPONSE_BODY
+    ].join("\r\n")
+  end
+  private_class_method :response
+
+  def server_context
+    key = OpenSSL::PKey::RSA.new(2048)
+    certificate = OpenSSL::X509::Certificate.new
+    certificate.version = 2
+    certificate.serial = 1
+    certificate.subject = certificate.issuer = OpenSSL::X509::Name.parse("/CN=127.0.0.1")
+    certificate.public_key = key.public_key
+    certificate.not_before = Time.now - 60
+    certificate.not_after = Time.now + 3600
+    certificate.sign(key, OpenSSL::Digest.new("SHA256"))
+
+    context = OpenSSL::SSL::SSLContext.new.tap do |ssl_context|
+      ssl_context.cert = certificate
+      ssl_context.key = key
+    end
+    [context, certificate.to_der]
+  end
+  private_class_method :server_context
+end

data/test/tls_info_test.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require_relative "support/tls_server"
+
+class TlsInfoTest < Minitest::Test
+  HTTPBIN_HTTP_URL = ENV.fetch("HTTPBIN_HTTP_URL", HTTPBIN_URL.sub(/\Ahttps:/, "http:"))
+
+  def test_tls_info_is_nil_when_disabled_or_request_is_plain_http
+    default_response = Wreq::Client.new.get("#{HTTPBIN_URL}/get")
+    plain_response = Wreq::Client.new(tls_info: true).get("#{HTTPBIN_HTTP_URL}/get")
+
+    assert_nil default_response.tls_info
+    assert_nil plain_response.tls_info
+  end
+
+  def test_certificate_data_survives_body_lifecycle_on_a_reused_connection
+    fixture = TlsTestServer.with_connection(request_count: 2) do |base_url, certificate_der|
+      client = Wreq::Client.new(
+        tls_info: true,
+        verify: false,
+        http1_only: true,
+        no_proxy: true,
+        timeout: 5
+      )
+
+      read_response = client.get("#{base_url}read")
+      assert_equal "ok", read_response.text
+      read_tls = read_response.tls_info
+
+      closed_response = client.get("#{base_url}close")
+      closed_response.close
+      closed_tls = closed_response.tls_info
+
+      assert_instance_of Wreq::TlsInfo, read_tls
+      certificate = read_tls.peer_certificate
+      chain = read_tls.peer_certificate_chain
+      assert_equal certificate_der, certificate
+      assert_equal Encoding::BINARY, certificate.encoding
+      assert_equal [certificate_der], chain
+      assert_equal Encoding::BINARY, chain.first.encoding
+      assert_predicate chain, :frozen?
+      assert_equal(
+        "#<Wreq::TlsInfo peer_certificate=#{certificate_der.bytesize}B peer_certificate_chain=1>",
+        read_tls.inspect
+      )
+      assert_empty Wreq::TlsInfo.instance_methods(false) & %i[to_h to_s]
+
+      certificate.clear
+      assert_equal certificate_der, read_tls.peer_certificate
+      assert_equal certificate_der, closed_tls.peer_certificate
+    end
+
+    assert_equal(
+      {connections: 1, requests: ["GET /read HTTP/1.1\r\n", "GET /close HTTP/1.1\r\n"]},
+      fixture
+    )
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wreq
 version: !ruby/object:Gem::Version
-  version: 1.2.10
+  version: 1.2.12
 platform: ruby
 authors:
 - SearchApi
@@ -80,6 +80,8 @@ files:
 - crates/wreq-util/tests/emulate_safari.rs
 - crates/wreq-util/tests/support/mod.rs
 - crates/wreq-util/tests/support/server.rs
+- docs/fork-safety.md
+- docs/interrupt-handling.md
 - docs/windows-gnu-tokio-crash.md
 - examples/body.rb
 - examples/client.rb
@@ -90,6 +92,7 @@ files:
 - examples/send_stream.rb
 - examples/stream.rb
 - examples/thread_interrupt.rb
+- examples/tls_info.rb
 - extconf.rb
 - lib/wreq.rb
 - lib/wreq_ruby/body.rb
@@ -100,6 +103,7 @@ files:
 - lib/wreq_ruby/header.rb
 - lib/wreq_ruby/http.rb
 - lib/wreq_ruby/response.rb
+- lib/wreq_ruby/tls.rb
 - script/build_platform_gem.rb
 - script/rust_env.rb
 - src/arch.rs
@@ -142,12 +146,14 @@ files:
 - src/serde/ser/struct_variant_serializer.rs
 - src/serde/ser/tuple_variant_serializer.rs
 - src/serde/tests.rs
+- src/tls.rs
 - test/body_sender_test.rb
 - test/client_cookie_test.rb
 - test/client_test.rb
 - test/cookie_test.rb
 - test/emulation_test.rb
 - test/error_handling_test.rb
+- test/fork_test.rb
 - test/header_test.rb
 - test/inspect_test.rb
 - test/json_precision_test.rb
@@ -157,8 +163,11 @@ files:
 - test/request_parameters_test.rb
 - test/request_test.rb
 - test/response_test.rb
+- test/scripts/fork_safety.rb
 - test/stream_test.rb
+- test/support/tls_server.rb
 - test/test_helper.rb
+- test/tls_info_test.rb
 - test/value_semantics_test.rb
 - wreq.gemspec
 homepage: https://github.com/SearchApi/wreq-ruby