wreq 1.2.5 → 1.2.6

data/src/serde/tests.rs

@@ -0,0 +1,237 @@
+use std::{collections::BTreeMap, fmt};
+
+use ::serde::{Deserialize, Serialize, de::Visitor};
+use magnus::{RArray, RHash, RString, Ruby, Value, encoding::EncodingCapable, value::ReprValue};
+
+use super::{deserialize_json, deserialize_ruby, serialize};
+
+#[derive(Debug, Deserialize, PartialEq, Serialize)]
+struct Record {
+    count: u64,
+    enabled: bool,
+    tags: Vec<String>,
+    note: Option<String>,
+}
+
+#[derive(Debug, Deserialize, PartialEq, Serialize)]
+struct UnitRecord;
+
+#[derive(Debug, Deserialize, PartialEq, Serialize)]
+struct NewtypeRecord(u64);
+
+#[derive(Debug, Deserialize, PartialEq, Serialize)]
+struct TupleRecord(u64, bool, String);
+
+#[derive(Debug, Deserialize, PartialEq, Serialize)]
+enum State {
+    Ready,
+    Count(u64),
+    Progress(u64, bool),
+    Failed { message: String },
+}
+
+/// Byte sequence that exercises Serde's owned byte-buffer entry points.
+#[derive(Debug, PartialEq)]
+struct ByteBuffer(Vec<u8>);
+
+impl Serialize for ByteBuffer {
+    fn serialize<Serializer>(
+        &self,
+        serializer: Serializer,
+    ) -> Result<Serializer::Ok, Serializer::Error>
+    where
+        Serializer: ::serde::Serializer,
+    {
+        serializer.serialize_bytes(&self.0)
+    }
+}
+
+impl<'de> Deserialize<'de> for ByteBuffer {
+    fn deserialize<Deserializer>(deserializer: Deserializer) -> Result<Self, Deserializer::Error>
+    where
+        Deserializer: ::serde::Deserializer<'de>,
+    {
+        struct ByteBufferVisitor;
+
+        impl<'de> Visitor<'de> for ByteBufferVisitor {
+            type Value = ByteBuffer;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+                formatter.write_str("an owned byte buffer")
+            }
+
+            fn visit_bytes<Error>(self, value: &[u8]) -> Result<Self::Value, Error>
+            where
+                Error: ::serde::de::Error,
+            {
+                Ok(ByteBuffer(value.to_vec()))
+            }
+
+            fn visit_byte_buf<Error>(self, value: Vec<u8>) -> Result<Self::Value, Error>
+            where
+                Error: ::serde::de::Error,
+            {
+                Ok(ByteBuffer(value))
+            }
+        }
+
+        deserializer.deserialize_byte_buf(ByteBufferVisitor)
+    }
+}
+
+/// Assert that a supported Serde value survives conversion through Ruby.
+fn assert_ruby_round_trip<Input>(ruby: &Ruby, input: Input) -> Result<(), magnus::Error>
+where
+    Input: fmt::Debug + PartialEq + Serialize + for<'de> Deserialize<'de>,
+{
+    let value: Value = serialize(ruby, &input)?;
+    let output: Input = deserialize_ruby(ruby, value)?;
+    assert_eq!(input, output);
+    Ok(())
+}
+
+/// Assert that a failed conversion preserves Ruby's `TypeError` classification.
+fn assert_type_error(error: magnus::Error, message: &str) {
+    let error = error.to_string();
+    assert!(error.starts_with("TypeError: "), "{error}");
+    assert!(error.contains(message), "{error}");
+}
+
+/// Verify scalar, option, result, and byte-string conversion behavior.
+fn assert_scalar_conversions(ruby: &Ruby) -> Result<(), magnus::Error> {
+    assert_ruby_round_trip(ruby, true)?;
+    assert_ruby_round_trip(ruby, 1.25_f32)?;
+    assert_ruby_round_trip(ruby, 1.25_f64)?;
+    assert_ruby_round_trip(ruby, Option::<u64>::None)?;
+    assert_ruby_round_trip(ruby, Some(123_u64))?;
+    assert_ruby_round_trip(ruby, Result::<u64, String>::Ok(1234))?;
+    assert_ruby_round_trip(ruby, Result::<u64, String>::Err("failed".to_owned()))?;
+
+    let character: RString = serialize(ruby, &'\u{2603}')?;
+    assert_eq!("\u{2603}", character.to_string()?);
+    assert!(character.enc_get() == ruby.utf8_encindex());
+    let output: char = deserialize_ruby(ruby, character)?;
+    assert_eq!('\u{2603}', output);
+
+    let string: RString = serialize(ruby, &"Hello, world!")?;
+    assert_eq!("Hello, world!", string.to_string()?);
+    assert!(string.enc_get() == ruby.utf8_encindex());
+    assert_eq!(
+        "Hello, world!",
+        deserialize_ruby::<_, String>(ruby, string)?
+    );
+
+    let bytes = ByteBuffer(b"\0binary\xff".to_vec());
+    let value: RString = serialize(ruby, &bytes)?;
+    assert_eq!(bytes.0.as_slice(), value.to_bytes().as_ref());
+    assert!(value.enc_get() == ruby.ascii8bit_encindex());
+    assert_eq!(bytes, deserialize_ruby(ruby, value)?);
+
+    let none: Value = serialize(ruby, &Option::<u64>::None)?;
+    assert!(none.is_nil());
+
+    let ok: RHash = serialize(ruby, &Result::<u64, String>::Ok(1234))?;
+    let value: u64 = ok.aref("Ok")?;
+    assert_eq!(1234, value);
+
+    let error: RHash = serialize(ruby, &Result::<u64, String>::Err("failed".to_owned()))?;
+    assert_eq!("failed", error.aref::<_, String>("Err")?);
+    Ok(())
+}
+
+/// Verify collection, tuple, struct, and enum conversion behavior.
+fn assert_composite_conversions(ruby: &Ruby) -> Result<(), magnus::Error> {
+    assert_ruby_round_trip(ruby, ())?;
+    assert_ruby_round_trip(ruby, [1_i64, 2, 3])?;
+    assert_ruby_round_trip(ruby, (123_i64, true, "tuple".to_owned()))?;
+    assert_ruby_round_trip(ruby, UnitRecord)?;
+    assert_ruby_round_trip(ruby, NewtypeRecord(123))?;
+    assert_ruby_round_trip(ruby, TupleRecord(123, true, "tuple struct".to_owned()))?;
+
+    let record = Record {
+        count: 42,
+        enabled: true,
+        tags: vec!["ruby".into(), "rust".into()],
+        note: Some("present".into()),
+    };
+    let value: RHash = serialize(ruby, &record)?;
+    let count: u64 = value.aref(ruby.to_symbol("count"))?;
+    assert_eq!(record.count, count);
+    assert_eq!(record, deserialize_ruby(ruby, value)?);
+
+    let map = BTreeMap::from([("first".to_owned(), 1_u64), ("second".to_owned(), 2)]);
+    assert_ruby_round_trip(ruby, map)?;
+
+    let tuple = (123_i64, true, "tuple".to_owned());
+    let value: RArray = serialize(ruby, &tuple)?;
+    assert_eq!(3, value.len());
+    let first: i64 = value.entry(0)?;
+    assert_eq!(123, first);
+
+    for state in [
+        State::Ready,
+        State::Count(2),
+        State::Progress(3, false),
+        State::Failed {
+            message: "failed".into(),
+        },
+    ] {
+        assert_ruby_round_trip(ruby, state)?;
+    }
+
+    let count: RHash = serialize(ruby, &State::Count(7))?;
+    let value: u64 = count.aref("Count")?;
+    assert_eq!(7, value);
+    Ok(())
+}
+
+/// Verify exact typed integer conversion in both deserialization modes.
+fn assert_integer_conversions(ruby: &Ruby) -> Result<(), magnus::Error> {
+    let value: Value = serialize(ruby, &i128::MIN)?;
+    let decimal: String = value.funcall("to_s", ())?;
+    assert_eq!(i128::MIN.to_string(), decimal);
+    assert_eq!(i128::MIN, deserialize_ruby::<_, i128>(ruby, value)?);
+    assert_eq!(i128::MIN, deserialize_json::<_, i128>(ruby, value)?);
+
+    let value: Value = serialize(ruby, &u128::MAX)?;
+    let decimal: String = value.funcall("to_s", ())?;
+    assert_eq!(u128::MAX.to_string(), decimal);
+    assert_eq!(u128::MAX, deserialize_ruby::<_, u128>(ruby, value)?);
+    assert_eq!(u128::MAX, deserialize_json::<_, u128>(ruby, value)?);
+
+    let value: Value = serialize(ruby, &u64::MAX)?;
+    assert_eq!(u64::MAX, deserialize_ruby::<_, u64>(ruby, value)?);
+    assert_eq!(u64::MAX, deserialize_json::<_, u64>(ruby, value)?);
+    Ok(())
+}
+
+/// Verify unsupported borrowed values and malformed enum shapes return errors.
+fn assert_conversion_errors(ruby: &Ruby) -> Result<(), magnus::Error> {
+    let error = deserialize_ruby::<_, &str>(ruby, ruby.str_new("borrowed"))
+        .expect_err("borrowed strings must not outlive their Ruby value");
+    assert_type_error(error, "expected a borrowed string");
+
+    let error = deserialize_ruby::<_, &[u8]>(ruby, ruby.str_new("borrowed"))
+        .expect_err("borrowed byte slices must not outlive their Ruby value");
+    assert_type_error(error, "can't deserialize into byte slice");
+
+    let variants = ruby.hash_new();
+    variants.aset("Ready", ruby.qnil())?;
+    variants.aset("Count", 1)?;
+    let error = deserialize_ruby::<_, State>(ruby, variants)
+        .expect_err("an enum hash must contain exactly one variant");
+    assert_type_error(error, "Hash of length 2");
+    Ok(())
+}
+
+#[test]
+fn retains_ruby_serde_conversion_surface() -> Result<(), magnus::Error> {
+    // SAFETY: this is the only test that initializes the embedded Ruby VM.
+    let ruby = unsafe { magnus::embed::init() };
+
+    assert_scalar_conversions(&ruby)?;
+    assert_composite_conversions(&ruby)?;
+    assert_integer_conversions(&ruby)?;
+    assert_conversion_errors(&ruby)?;
+    Ok(())
+}

data/src/serde.rs

@@ -0,0 +1,202 @@
+/*
+Copyright 2022 George Claghorn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+//! Serde integration for Magnus with JSON-specific conversion behavior.
+//!
+//! This module is adapted from `serde_magnus` 0.11.0 and retains its generic
+//! Ruby serialization and deserialization surface. Local changes add a JSON
+//! mode with arbitrary-size integer support, finite-float and object-key
+//! validation, insertion-order preservation, and bounded container nesting.
+//! The bridge also avoids the upstream `Ruby::get().unwrap()` error path,
+//! checks iterator and map state explicitly, reports unknown option fields and
+//! conversion paths, and supports `i128` and `u128` in both directions for
+//! typed Rust values.
+#![allow(unsafe_code)]
+
+mod de;
+mod error;
+mod ser;
+#[cfg(test)]
+mod tests;
+
+use ::serde::{Deserialize, Serialize, de::DeserializeOwned};
+use indexmap::IndexSet;
+use magnus::{IntoValue, Ruby, TryConvert};
+use serde_ignored::Path;
+use serde_path_to_error::{Deserializer as PathDeserializer, Track};
+
+use crate::error::argument_error;
+
+pub(super) use error::Error;
+
+/// Private map key used to carry arbitrary-precision numbers through Serde.
+///
+/// This mirrors the representation used by `serde_json` when its
+/// `arbitrary_precision` feature is enabled. The precision tests protect this
+/// integration point when `serde_json` is updated.
+pub(super) const JSON_NUMBER_TOKEN: &str = "$serde_json::private::Number";
+
+/// Maximum nesting accepted while converting a Ruby request value.
+pub(super) const MAX_JSON_NESTING: usize = 100;
+
+/// Deserialize a Ruby value using native Ruby data model semantics.
+///
+/// This preserves the public conversion behavior provided by the upstream
+/// `serde_magnus::deserialize` function. JSON callers should use
+/// [`deserialize_json`] when arbitrary-size integer precision is required.
+///
+/// # Errors
+///
+/// Returns the Ruby exception produced when the input cannot be represented by
+/// `Output`.
+#[allow(dead_code)] // Retained as part of the upstream-compatible Serde surface.
+pub(crate) fn deserialize_ruby<'de, Input, Output>(
+    ruby: &Ruby,
+    input: Input,
+) -> Result<Output, magnus::Error>
+where
+    Input: IntoValue,
+    Output: Deserialize<'de>,
+{
+    de::deserialize_ruby(ruby, input.into_value_with(ruby)).map_err(|error| error.into_magnus(ruby))
+}
+
+/// Serialize any Serde value into a Ruby value.
+///
+/// This preserves the public conversion behavior provided by the upstream
+/// `serde_magnus::serialize` function.
+///
+/// # Errors
+///
+/// Returns the Ruby exception produced while creating or converting the output
+/// value.
+pub(crate) fn serialize<Input, Output>(ruby: &Ruby, input: &Input) -> Result<Output, magnus::Error>
+where
+    Input: Serialize + ?Sized,
+    Output: TryConvert,
+{
+    let value = ser::serialize(ruby, input).map_err(|error| error.into_magnus(ruby))?;
+    Output::try_convert(value)
+}
+
+/// Deserialize a Ruby value using JSON-specific conversion rules.
+///
+/// Unlike [`deserialize_ruby`], this preserves arbitrary-size integers and
+/// rejects non-finite floats, unsupported object keys, and excessive nesting.
+///
+/// # Errors
+///
+/// Returns the Ruby exception produced when the input cannot be represented by
+/// `Output`.
+pub(crate) fn deserialize_json<'de, Input, Output>(
+    ruby: &Ruby,
+    input: Input,
+) -> Result<Output, magnus::Error>
+where
+    Input: IntoValue,
+    Output: Deserialize<'de>,
+{
+    de::deserialize_json(ruby, input.into_value_with(ruby)).map_err(|error| error.into_magnus(ruby))
+}
+
+/// Validate Ruby option keys without inspecting their values.
+///
+/// The derived struct is the only list of accepted keys. Every option field is
+/// optional, so this pass can collect unknown keys and duplicates without
+/// converting or retaining any Ruby value.
+///
+/// # Errors
+///
+/// Returns `ArgumentError` for unknown or duplicate keys and `TypeError` for
+/// keys that are neither Ruby Symbols nor Strings.
+pub(crate) fn validate_option_keys<Input, Output>(
+    ruby: &Ruby,
+    input: Input,
+) -> Result<(), magnus::Error>
+where
+    Input: IntoValue,
+    Output: DeserializeOwned,
+{
+    let value: magnus::Value = input.into_value_with(ruby);
+    let mut unknown = IndexSet::new();
+    {
+        let mut callback = |path: Path<'_>| {
+            if let Path::Map { key, .. } = path {
+                unknown.insert(key);
+            }
+        };
+        serde_ignored::deserialize::<_, _, Output>(
+            de::Deserializer::new_option_keys(ruby, value),
+            &mut callback,
+        )
+        .map_err(|error| error.into_option_magnus(ruby, None))?;
+    }
+
+    if unknown.is_empty() {
+        return Ok(());
+    }
+
+    let label = if unknown.len() == 1 {
+        "unknown option"
+    } else {
+        "unknown options"
+    };
+    let mut message = String::from(label);
+    message.push(':');
+    for (index, name) in unknown.into_iter().enumerate() {
+        if index > 0 {
+            message.push(',');
+        }
+        message.push(' ');
+        message.push(':');
+        message.push_str(&name);
+    }
+
+    Err(argument_error(ruby, message))
+}
+
+/// Deserialize validated Ruby options and retain the failing field path.
+///
+/// # Errors
+///
+/// Returns the Ruby conversion error with the failing option path attached.
+pub(crate) fn deserialize_options<Input, Output>(
+    ruby: &Ruby,
+    input: Input,
+) -> Result<Output, magnus::Error>
+where
+    Input: IntoValue,
+    Output: DeserializeOwned,
+{
+    let value = input.into_value_with(ruby);
+    let mut track = Track::new();
+    let result = Output::deserialize(PathDeserializer::new(
+        de::Deserializer::new_ruby(ruby, value),
+        &mut track,
+    ));
+
+    result.map_err(|error| {
+        let path = track.path();
+        let path = path.iter().next().is_some().then_some(&path);
+        error.into_option_magnus(ruby, path)
+    })
+}

data/test/body_sender_test.rb

@@ -0,0 +1,246 @@
+require "test_helper"
+require "open3"
+require "rbconfig"
+require "socket"
+
+class BodySenderTest < Minitest::Test
+  def test_valid_capacity_creates_open_sender
+    sender = Wreq::BodySender.new(2)
+
+    refute_predicate sender, :closed?
+  ensure
+    sender&.close
+  end
+
+  def test_omitted_capacity_defaults_to_eight
+    sender = Wreq::BodySender.new
+    progress = Queue.new
+    producer = Thread.new do
+      9.times do |index|
+        sender.push(index.to_s)
+        progress << index
+      end
+      sender.close
+    end
+    producer.report_on_exception = false
+
+    assert wait_until { progress.size >= 8 }, "the default channel should buffer eight chunks"
+    assert_equal 8, progress.size
+    assert_predicate producer, :alive?, "the ninth push should wait for channel capacity"
+
+    with_request_body_server do |url, request_thread|
+      response = Wreq.post(url, body: sender)
+
+      assert_equal 200, response.code
+      assert producer.join(5), "the ninth push should finish once the request drains"
+      assert_equal "012345678", request_thread.value
+    end
+  ensure
+    producer&.kill if producer&.alive?
+    producer&.join(5)
+    sender&.close
+  end
+
+  def test_non_positive_and_excessive_capacities_raise_argument_error
+    [0, -1, 2**256].each do |capacity|
+      error = assert_raises(ArgumentError) { Wreq::BodySender.new(capacity) }
+      assert_match(/capacity/, error.message)
+    end
+  end
+
+  def test_non_integer_capacities_raise_type_error
+    [1.0, "not an integer"].each do |capacity|
+      error = assert_raises(TypeError) { Wreq::BodySender.new(capacity) }
+      assert_match(/capacity/, error.message)
+    end
+  end
+
+  def test_too_many_constructor_arguments_raise_argument_error
+    assert_raises(ArgumentError) { Wreq::BodySender.new(1, 2) }
+  end
+
+  def test_close_is_idempotent_and_updates_closed_state
+    sender = Wreq::BodySender.new
+
+    refute_predicate sender, :closed?
+    assert_nil sender.close
+    assert_predicate sender, :closed?
+    assert_nil sender.close
+  end
+
+  def test_push_after_close_raises_io_error
+    sender = Wreq::BodySender.new
+    sender.close
+
+    error = assert_raises(IOError) { sender.push("data") }
+    assert_equal "closed body sender", error.message
+  end
+
+  def test_queued_chunks_survive_close_before_request_attachment
+    sender = Wreq::BodySender.new(2)
+    sender.push("queued-")
+    sender.push("body")
+    sender.close
+
+    with_request_body_server do |url, request_thread|
+      response = Wreq.post(url, body: sender)
+
+      assert_equal 200, response.code
+      assert_equal "queued-body", request_thread.value
+    end
+  end
+
+  def test_valid_capacity_keeps_backpressure_until_request_drains
+    sender = Wreq::BodySender.new(1)
+    sender.push("first-")
+    producer = Thread.new do
+      sender.push("second")
+      sender.close
+    end
+    producer.report_on_exception = false
+
+    sleep 0.05
+    assert_predicate producer, :alive?, "the second push should wait for channel capacity"
+
+    with_request_body_server do |url, request_thread|
+      response = Wreq.post(url, body: sender)
+
+      assert_equal 200, response.code
+      assert producer.join(5), "the blocked producer should finish once the request drains"
+      assert_equal "first-second", request_thread.value
+    end
+  ensure
+    producer&.kill if producer&.alive?
+    producer&.join(5)
+    sender&.close
+  end
+
+  def test_receiver_termination_closes_sender
+    sender = Wreq::BodySender.new(1)
+    sender.push("data")
+
+    with_reset_server do |url|
+      assert_raises(StandardError) { Wreq.post(url, body: sender, timeout: 2) }
+    end
+
+    assert wait_until { sender.closed? }, "sender should close after the request drops its receiver"
+    assert_raises(IOError) { sender.push("more") }
+  ensure
+    sender&.close
+  end
+
+  def test_zero_capacity_regression_exits_subprocess_normally
+    lib_dir = File.expand_path("../lib", __dir__)
+    script = <<~RUBY
+      require "wreq"
+
+      begin
+        Wreq::BodySender.new(0)
+      rescue ArgumentError => error
+        warn "\#{error.class}: \#{error.message}"
+        exit 0
+      end
+
+      warn "zero capacity did not raise"
+      exit 2
+    RUBY
+
+    _stdout, stderr, status = Open3.capture3(RbConfig.ruby, "-I", lib_dir, "-e", script)
+
+    assert status.success?, "subprocess failed with #{status.inspect}: #{stderr}"
+    assert_match(/ArgumentError:.*capacity/, stderr)
+    refute_match(/panicked|mpsc bounded channel/i, stderr)
+  end
+
+  private
+
+  def wait_until(timeout: 2)
+    deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+    loop do
+      return true if yield
+      return false if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+      sleep 0.01
+    end
+  end
+
+  def with_request_body_server
+    server = TCPServer.new("127.0.0.1", 0)
+    port = server.addr[1]
+    request_thread = Thread.new do
+      socket = server.accept
+      begin
+        socket.gets
+        headers = read_headers(socket)
+        body = read_request_body(socket, headers)
+        socket.write "HTTP/1.1 200 OK\r\n"
+        socket.write "Content-Length: 0\r\n"
+        socket.write "Connection: close\r\n\r\n"
+        body
+      ensure
+        socket.close unless socket.closed?
+      end
+    ensure
+      server.close unless server.closed?
+    end
+    request_thread.report_on_exception = false
+
+    yield "http://127.0.0.1:#{port}/", request_thread
+  ensure
+    server&.close unless server&.closed?
+    request_thread&.join(5)
+  end
+
+  def with_reset_server
+    server = TCPServer.new("127.0.0.1", 0)
+    port = server.addr[1]
+    thread = Thread.new do
+      socket = server.accept
+      socket.close
+    ensure
+      server.close unless server.closed?
+    end
+    thread.report_on_exception = false
+
+    yield "http://127.0.0.1:#{port}/"
+  ensure
+    server&.close unless server&.closed?
+    thread&.join(5)
+  end
+
+  def read_headers(socket)
+    headers = {}
+    while (line = socket.gets)
+      break if line == "\r\n"
+
+      name, value = line.split(":", 2)
+      headers[name.downcase] = value.strip
+    end
+    headers
+  end
+
+  def read_request_body(socket, headers)
+    if headers.fetch("transfer-encoding", "").downcase.include?("chunked")
+      read_chunked_body(socket)
+    else
+      socket.read(headers.fetch("content-length", "0").to_i)
+    end
+  end
+
+  def read_chunked_body(socket)
+    body = "".b
+    loop do
+      size_line = socket.gets or raise EOFError, "missing chunk size"
+      size = Integer(size_line.split(";", 2).first, 16)
+      break if size.zero?
+
+      body << socket.read(size)
+      raise IOError, "missing chunk terminator" unless socket.read(2) == "\r\n"
+    end
+
+    while (line = socket.gets)
+      break if line == "\r\n"
+    end
+    body
+  end
+end