584 lines
18 KiB
Crystal
584 lines
18 KiB
Crystal
require "http"
|
|
require "socket"
|
|
|
|
module QUIC
|
|
class StreamCtx
|
|
property request : HTTP::Request
|
|
property io : IO::ChanneledPipe
|
|
|
|
def initialize(@request, @io)
|
|
end
|
|
end
|
|
|
|
class Client
|
|
REQUIRED_HEADERS = {":method", ":scheme", ":path", ":authority"}
|
|
|
|
def self.stream_readf(stream_if_ctx : Void*, buf : UInt8*, buf_len : LibC::SizeT, fin : LibC::Int)
|
|
stream_ctx = Box(StreamCtx).unbox(stream_if_ctx)
|
|
stream_ctx.io.write Slice.new(buf, buf_len)
|
|
buf_len
|
|
end
|
|
|
|
def self.on_new_conn(stream_if_ctx : Void*, c : LibLsquic::ConnT)
|
|
stream_if_ctx
|
|
end
|
|
|
|
def self.on_conn_closed(c : LibLsquic::ConnT)
|
|
Box.box(nil)
|
|
end
|
|
|
|
def self.on_new_stream(stream_if_ctx : Void*, s : LibLsquic::StreamT)
|
|
stream_ctx = LibLsquic.stream_conn(s)
|
|
.try { |c| LibLsquic.conn_get_ctx(c) }
|
|
.try { |c| Box(StreamCtx).unbox(c) }
|
|
|
|
return Box.box(stream_ctx) if LibLsquic.stream_is_pushed(s) != 0
|
|
|
|
LibLsquic.stream_wantwrite(s, 1)
|
|
Box.box(stream_ctx)
|
|
end
|
|
|
|
def self.on_write(s : LibLsquic::StreamT, stream_if_ctx : Void*)
|
|
stream_ctx = Box(StreamCtx).unbox(stream_if_ctx)
|
|
request_headers = stream_ctx.request.headers
|
|
|
|
headers = [] of LibLsquic::LsxpackHeader
|
|
REQUIRED_HEADERS.each do |name|
|
|
value = stream_ctx.request.headers[name]
|
|
headers << LibLsquic::LsxpackHeader.new(
|
|
buf: "#{name}#{value}",
|
|
name_len: name.bytesize,
|
|
name_offset: 0,
|
|
val_len: value.bytesize,
|
|
val_offset: name.bytesize
|
|
)
|
|
end
|
|
|
|
request_headers.each do |name, values|
|
|
name = name.downcase
|
|
next if REQUIRED_HEADERS.includes? name
|
|
headers << LibLsquic::LsxpackHeader.new(
|
|
buf: "#{name}#{values[0]}",
|
|
name_len: name.bytesize,
|
|
name_offset: 0,
|
|
val_len: values[0].bytesize,
|
|
val_offset: name.bytesize
|
|
)
|
|
end
|
|
|
|
http_headers = LibLsquic::HttpHeaders.new(count: headers.size, headers: headers.to_unsafe)
|
|
|
|
raise "Could not send headers" if LibLsquic.stream_send_headers(s, pointerof(http_headers), stream_ctx.request.body ? 0 : 1) != 0
|
|
|
|
if body = stream_ctx.request.body.try &.gets_to_end
|
|
LibLsquic.stream_write(s, body, body.bytesize)
|
|
LibLsquic.stream_flush(s)
|
|
end
|
|
|
|
LibLsquic.stream_shutdown(s, 1)
|
|
LibLsquic.stream_wantwrite(s, 0)
|
|
LibLsquic.stream_wantread(s, 1)
|
|
|
|
Box.box(stream_ctx)
|
|
end
|
|
|
|
def self.on_read(s : LibLsquic::StreamT, stream_if_ctx : Void*)
|
|
stream_ctx = Box(StreamCtx).unbox(stream_if_ctx)
|
|
bytes_read = LibLsquic.stream_readf(s, ->stream_readf, Box.box(stream_ctx))
|
|
|
|
if bytes_read > 0
|
|
# Nothing
|
|
elsif bytes_read == 0
|
|
LibLsquic.stream_shutdown(s, 0)
|
|
LibLsquic.stream_wantread(s, 0)
|
|
elsif LibLsquic.stream_is_rejected(s) == 1
|
|
LibLsquic.stream_close(s)
|
|
else
|
|
# raise "Could not read response"
|
|
end
|
|
|
|
stream_if_ctx
|
|
end
|
|
|
|
def self.on_close(s : LibLsquic::StreamT, stream_if_ctx : Void*)
|
|
stream_ctx = Box(StreamCtx).unbox(stream_if_ctx)
|
|
stream_ctx.io.close
|
|
GC.free stream_if_ctx
|
|
stream_if_ctx
|
|
end
|
|
|
|
def self.ea_packets_out(peer_ctx : Void*, specs : LibLsquic::OutSpec*, count : LibC::UInt)
|
|
packets_out = 0
|
|
|
|
count.times do |i|
|
|
spec = specs[i]
|
|
socket = Box(UDPSocket).unbox(spec.peer_ctx)
|
|
spec.iovlen.times do |j|
|
|
iov = spec.iov[j]
|
|
begin
|
|
socket.send(iov.iov_base.to_slice(iov.iov_len), to: socket.remote_address)
|
|
packets_out += 1
|
|
rescue ex
|
|
break
|
|
end
|
|
end
|
|
end
|
|
|
|
packets_out
|
|
end
|
|
|
|
ENGINE_FLAGS = LibLsquic::LSENG_HTTP
|
|
LibLsquic.global_init(ENGINE_FLAGS & LibLsquic::LSENG_SERVER ? LibLsquic::GLOBAL_SERVER : LibLsquic::GLOBAL_CLIENT)
|
|
|
|
property family : Socket::Family = Socket::Family::INET
|
|
|
|
# The set of possible valid body types.
|
|
alias BodyType = String | Bytes | IO | Nil
|
|
|
|
getter host : String
|
|
getter port : Int32
|
|
getter! tls : OpenSSL::SSL::Context::Client
|
|
|
|
@stream_channel : Channel(StreamCtx?)
|
|
@dns_timeout : Float64?
|
|
@connect_timeout : Float64?
|
|
@read_timeout : Float64?
|
|
@socket : UDPSocket?
|
|
@stream_ctx : StreamCtx?
|
|
|
|
def initialize(@host : String, port = nil, tls : Bool | OpenSSL::SSL::Context::Client = false)
|
|
check_host_only(@host)
|
|
|
|
@tls = case tls
|
|
when true
|
|
OpenSSL::SSL::Context::Client.new
|
|
when OpenSSL::SSL::Context::Client
|
|
tls
|
|
when false
|
|
nil
|
|
end
|
|
|
|
@port = (port || 443).to_i
|
|
@stream_channel = Channel(StreamCtx?).new(20)
|
|
@stream_ctx = nil
|
|
@engine_open = false
|
|
end
|
|
|
|
def run_engine
|
|
LibLsquic.engine_init_settings(out engine_settings, ENGINE_FLAGS)
|
|
engine_settings.es_ua = "Chrome/83.0.4103.61 Linux x86_64"
|
|
engine_settings.es_ecn = 0
|
|
|
|
err_buf = Bytes.new(0x100)
|
|
err_code = LibLsquic.engine_check_settings(pointerof(engine_settings), ENGINE_FLAGS, err_buf, err_buf.size)
|
|
raise String.new(err_buf) if err_code != 0
|
|
|
|
stream_if = LibLsquic::StreamIf.new
|
|
stream_if.on_new_conn = ->QUIC::Client.on_new_conn(Void*, LibLsquic::ConnT)
|
|
stream_if.on_conn_closed = ->QUIC::Client.on_conn_closed(LibLsquic::ConnT)
|
|
stream_if.on_new_stream = ->QUIC::Client.on_new_stream(Void*, LibLsquic::StreamT)
|
|
stream_if.on_write = ->QUIC::Client.on_write(LibLsquic::StreamT, Void*)
|
|
stream_if.on_read = ->QUIC::Client.on_read(LibLsquic::StreamT, Void*)
|
|
stream_if.on_close = ->QUIC::Client.on_close(LibLsquic::StreamT, Void*)
|
|
|
|
engine_api = LibLsquic::EngineApi.new
|
|
engine_api.ea_settings = pointerof(engine_settings)
|
|
engine_api.ea_stream_if = pointerof(stream_if)
|
|
engine_api.ea_packets_out = ->QUIC::Client.ea_packets_out(Void*, LibLsquic::OutSpec*, LibC::UInt)
|
|
|
|
# logger_if = LibLsquic::LoggerIf.new
|
|
# logger_if.log_buf = ->(logger_ctx : Void*, msg_buf : LibC::Char*, msg_size : LibC::SizeT) { puts String.new(msg_buf); 0 }
|
|
# LibLsquic.logger_init(pointerof(logger_if), nil, LibLsquic::LoggerTimestampStyle::LltsHhmmssms)
|
|
# LibLsquic.set_log_level("debug")
|
|
|
|
engine = LibLsquic.engine_new(ENGINE_FLAGS, pointerof(engine_api))
|
|
hostname = host.starts_with?('[') && host.ends_with?(']') ? host[1..-2] : host
|
|
@engine_open = true
|
|
|
|
conn = LibLsquic.engine_connect(
|
|
engine,
|
|
LibLsquic::Version::Lsqver050,
|
|
socket.local_address,
|
|
socket.remote_address,
|
|
Box.box(socket), nil,
|
|
hostname, 0,
|
|
nil, 0,
|
|
nil, 0
|
|
)
|
|
spawn do
|
|
while stream_ctx = @stream_channel.receive
|
|
LibLsquic.conn_set_ctx(conn, Box.box(stream_ctx))
|
|
LibLsquic.conn_make_stream(conn)
|
|
LibLsquic.engine_process_conns(engine)
|
|
end
|
|
@engine_open = false
|
|
LibLsquic.engine_destroy(engine)
|
|
@socket.try &.close
|
|
@socket = nil
|
|
end
|
|
|
|
begin
|
|
buffer = Bytes.new(0x600)
|
|
loop do
|
|
bytes_read = socket.read buffer
|
|
break if !@engine_open
|
|
LibLsquic.engine_packet_in(engine, buffer[0, bytes_read], bytes_read, socket.local_address, socket.remote_address, Box.box(socket), 0) if bytes_read != 0
|
|
LibLsquic.engine_process_conns(engine)
|
|
end
|
|
rescue IO::Error
|
|
# may have already been closed
|
|
ensure
|
|
@socket.try &.close
|
|
@socket = nil
|
|
end
|
|
end
|
|
|
|
def socket : UDPSocket
|
|
socket = @socket
|
|
return socket.not_nil! if @socket
|
|
|
|
socket = UDPSocket.new @family
|
|
case @family
|
|
when Socket::Family::INET
|
|
socket.bind Socket::IPAddress.new("0.0.0.0", 0)
|
|
when Socket::Family::INET6
|
|
socket.bind Socket::IPAddress.new("::", 0)
|
|
else
|
|
socket.bind Socket::IPAddress.new("0.0.0.0", 0)
|
|
end
|
|
|
|
Socket::Addrinfo.udp(@host, @port, timeout: @dns_timeout, family: @family) do |addrinfo|
|
|
socket.connect(addrinfo, timeout: @connect_timeout) do |error|
|
|
close
|
|
error
|
|
end
|
|
end
|
|
|
|
socket.read_timeout = @read_timeout if @read_timeout
|
|
socket.sync = false
|
|
|
|
@socket = socket
|
|
end
|
|
|
|
private def check_host_only(string : String)
|
|
# When parsing a URI with just a host
|
|
# we end up with a URI with just a path
|
|
uri = URI.parse(string)
|
|
if uri.scheme || uri.host || uri.port || uri.query || uri.user || uri.password || uri.path.includes?('/')
|
|
raise_invalid_host(string)
|
|
end
|
|
rescue URI::Error
|
|
raise_invalid_host(string)
|
|
end
|
|
|
|
private def raise_invalid_host(string : String)
|
|
raise ArgumentError.new("The string passed to create an HTTP::Client must be just a host, not #{string.inspect}")
|
|
end
|
|
|
|
def self.new(uri : URI, tls = nil)
|
|
tls = tls_flag(uri, tls)
|
|
host = validate_host(uri)
|
|
new(host, uri.port, tls)
|
|
end
|
|
|
|
def self.new(uri : URI, tls = nil)
|
|
tls = tls_flag(uri, tls)
|
|
host = validate_host(uri)
|
|
client = new(host, uri.port, tls)
|
|
begin
|
|
yield client
|
|
ensure
|
|
client.close
|
|
end
|
|
end
|
|
|
|
def self.new(host : String, port = nil, tls = false)
|
|
client = new(host, port, tls)
|
|
begin
|
|
yield client
|
|
ensure
|
|
client.close
|
|
end
|
|
end
|
|
|
|
# Configures this client to perform basic authentication in every
|
|
# request.
|
|
def basic_auth(username, password)
|
|
header = "Basic #{Base64.strict_encode("#{username}:#{password}")}"
|
|
before_request do |request|
|
|
request.headers["Authorization"] = header
|
|
end
|
|
end
|
|
|
|
def read_timeout=(read_timeout : Number)
|
|
@read_timeout = read_timeout.to_f
|
|
end
|
|
|
|
def read_timeout=(read_timeout : Time::Span)
|
|
self.read_timeout = read_timeout.total_seconds
|
|
end
|
|
|
|
def connect_timeout=(connect_timeout : Number)
|
|
@connect_timeout = connect_timeout.to_f
|
|
end
|
|
|
|
def connect_timeout=(connect_timeout : Time::Span)
|
|
self.connect_timeout = connect_timeout.total_seconds
|
|
end
|
|
|
|
def dns_timeout=(dns_timeout : Number)
|
|
@dns_timeout = dns_timeout.to_f
|
|
end
|
|
|
|
def dns_timeout=(dns_timeout : Time::Span)
|
|
self.dns_timeout = dns_timeout.total_seconds
|
|
end
|
|
|
|
def before_request(&callback : HTTP::Request ->)
|
|
before_request = @before_request ||= [] of (HTTP::Request ->)
|
|
before_request << callback
|
|
end
|
|
|
|
{% for method in %w(get post put head delete patch options) %}
|
|
def {{method.id}}(path, headers : HTTP::Headers? = nil, body : BodyType = nil) : HTTP::Client::Response
|
|
exec {{method.upcase}}, path, headers, body
|
|
end
|
|
|
|
def {{method.id}}(path, headers : HTTP::Headers? = nil, body : BodyType = nil)
|
|
exec {{method.upcase}}, path, headers, body do |response|
|
|
yield response
|
|
end
|
|
end
|
|
|
|
def self.{{method.id}}(url : String | URI, headers : HTTP::Headers? = nil, body : BodyType = nil, tls = nil) : HTTP::Client::Response
|
|
exec {{method.upcase}}, url, headers, body, tls
|
|
end
|
|
|
|
def self.{{method.id}}(url : String | URI, headers : HTTP::Headers? = nil, body : BodyType = nil, tls = nil)
|
|
exec {{method.upcase}}, url, headers, body, tls do |response|
|
|
yield response
|
|
end
|
|
end
|
|
|
|
def {{method.id}}(path, headers : HTTP::Headers? = nil, *, form : String | IO) : HTTP::Client::Response
|
|
request = new_request({{method.upcase}}, path, headers, form)
|
|
request.headers["Content-Type"] = "application/x-www-form-urlencoded"
|
|
exec request
|
|
end
|
|
|
|
def {{method.id}}(path, headers : HTTP::Headers? = nil, *, form : String | IO)
|
|
request = new_request({{method.upcase}}, path, headers, form)
|
|
request.headers["Content-Type"] = "application/x-www-form-urlencoded"
|
|
exec(request) do |response|
|
|
yield response
|
|
end
|
|
end
|
|
|
|
def {{method.id}}(path, headers : HTTP::Headers? = nil, *, form : Hash(String, String) | NamedTuple) : HTTP::Client::Response
|
|
body = HTTP::Params.encode(form)
|
|
{{method.id}} path, form: body, headers: headers
|
|
end
|
|
|
|
def {{method.id}}(path, headers : HTTP::Headers? = nil, *, form : Hash(String, String) | NamedTuple)
|
|
body = HTTP::Params.encode(form)
|
|
{{method.id}}(path, form: body, headers: headers) do |response|
|
|
yield response
|
|
end
|
|
end
|
|
|
|
def self.{{method.id}}(url, headers : HTTP::Headers? = nil, tls = nil, *, form : String | IO | Hash) : HTTP::Client::Response
|
|
exec(url, tls) do |client, path|
|
|
client.{{method.id}}(path, form: form, headers: headers)
|
|
end
|
|
end
|
|
|
|
def self.{{method.id}}(url, headers : HTTP::Headers? = nil, tls = nil, *, form : String | IO | Hash)
|
|
exec(url, tls) do |client, path|
|
|
client.{{method.id}}(path, form: form, headers: headers) do |response|
|
|
yield response
|
|
end
|
|
end
|
|
end
|
|
{% end %}
|
|
|
|
def exec(request : HTTP::Request) : HTTP::Client::Response
|
|
exec_internal(request)
|
|
end
|
|
|
|
private def exec_internal(request)
|
|
response = exec_internal_single(request)
|
|
return handle_response(response) if response
|
|
|
|
raise "Unexpected end of http response"
|
|
end
|
|
|
|
private def exec_internal_single(request)
|
|
io = send_request(request)
|
|
HTTP::Client::Response.from_io?(io, ignore_body: request.ignore_body?)
|
|
end
|
|
|
|
private def handle_response(response)
|
|
# close unless response.keep_alive?
|
|
response
|
|
end
|
|
|
|
def exec(request : HTTP::Request, &block)
|
|
exec_internal(request) do |response|
|
|
yield response
|
|
end
|
|
end
|
|
|
|
private def exec_internal(request, &block : HTTP::Client::Response -> T) : T forall T
|
|
exec_internal_single(request) do |response|
|
|
if response
|
|
return handle_response(response) { yield response }
|
|
end
|
|
end
|
|
raise "Unexpected end of http response"
|
|
end
|
|
|
|
private def exec_internal_single(request)
|
|
io = send_request(request)
|
|
HTTP::Client::Response.from_io?(io, ignore_body: request.ignore_body?) do |response|
|
|
yield response
|
|
end
|
|
end
|
|
|
|
private def handle_response(response)
|
|
value = yield
|
|
response.body_io?.try &.close
|
|
# close unless response.keep_alive?
|
|
value
|
|
end
|
|
|
|
private def send_request(request)
|
|
set_defaults request
|
|
run_before_request_callbacks(request)
|
|
|
|
spawn run_engine if !@engine_open
|
|
|
|
reader, writer = IO::ChanneledPipe.new
|
|
# See https://github.com/crystal-lang/crystal/blob/0.32.0/src/openssl/ssl/context.cr#L126
|
|
@stream_ctx = StreamCtx.new(request, writer)
|
|
@stream_channel.send @stream_ctx
|
|
reader
|
|
end
|
|
|
|
private def set_defaults(request)
|
|
request.headers[":method"] ||= request.method
|
|
request.headers[":scheme"] ||= "https"
|
|
request.headers[":path"] ||= request.resource
|
|
request.headers[":authority"] ||= host_header
|
|
request.headers["user-agent"] ||= "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.97 Safari/537.36"
|
|
end
|
|
|
|
private def self.default_one_shot_headers(headers)
|
|
headers ||= HTTP::Headers.new
|
|
headers["connection"] ||= "close"
|
|
headers
|
|
end
|
|
|
|
private def run_before_request_callbacks(request)
|
|
@before_request.try &.each &.call(request)
|
|
end
|
|
|
|
def exec(method : String, path, headers : HTTP::Headers? = nil, body : BodyType = nil) : HTTP::Client::Response
|
|
exec new_request method, path, headers, body
|
|
end
|
|
|
|
def exec(method : String, path, headers : HTTP::Headers? = nil, body : BodyType = nil)
|
|
exec(new_request(method, path, headers, body)) do |response|
|
|
yield response
|
|
end
|
|
end
|
|
|
|
def self.exec(method, url : String | URI, headers : HTTP::Headers? = nil, body : BodyType = nil, tls = nil) : HTTP::Client::Response
|
|
headers = default_one_shot_headers(headers)
|
|
exec(url, tls) do |client, path|
|
|
client.exec method, path, headers, body
|
|
end
|
|
end
|
|
|
|
def self.exec(method, url : String | URI, headers : HTTP::Headers? = nil, body : BodyType = nil, tls = nil)
|
|
headers = default_one_shot_headers(headers)
|
|
exec(url, tls) do |client, path|
|
|
client.exec(method, path, headers, body) do |response|
|
|
yield response
|
|
end
|
|
end
|
|
end
|
|
|
|
def close
|
|
@stream_channel.send nil
|
|
Fiber.yield
|
|
end
|
|
|
|
private def new_request(method, path, headers, body : BodyType)
|
|
HTTP::Request.new(method, path, headers, body)
|
|
end
|
|
|
|
private def host_header
|
|
if (@tls && @port != 443) || (!@tls && @port != 80)
|
|
"#{@host}:#{@port}"
|
|
else
|
|
@host
|
|
end
|
|
end
|
|
|
|
private def self.exec(string : String, tls = nil)
|
|
uri = URI.parse(string)
|
|
|
|
unless uri.scheme && uri.host
|
|
# Assume http if no scheme and host are specified
|
|
uri = URI.parse("http://#{string}")
|
|
end
|
|
|
|
exec(uri, tls) do |client, path|
|
|
yield client, path
|
|
end
|
|
end
|
|
|
|
protected def self.tls_flag(uri, context : OpenSSL::SSL::Context::Client?)
|
|
scheme = uri.scheme
|
|
case {scheme, context}
|
|
when {nil, _}
|
|
raise ArgumentError.new("Missing scheme: #{uri}")
|
|
when {"http", nil}
|
|
false
|
|
when {"http", OpenSSL::SSL::Context::Client}
|
|
raise ArgumentError.new("TLS context given for HTTP URI")
|
|
when {"https", nil}
|
|
true
|
|
when {"https", OpenSSL::SSL::Context::Client}
|
|
context
|
|
else
|
|
raise ArgumentError.new "Unsupported scheme: #{scheme}"
|
|
end
|
|
end
|
|
|
|
protected def self.validate_host(uri)
|
|
host = uri.host
|
|
return host if host && !host.empty?
|
|
|
|
raise ArgumentError.new %(Request URI must have host (URI is: #{uri}))
|
|
end
|
|
|
|
private def self.exec(uri : URI, tls = nil)
|
|
tls = tls_flag(uri, tls)
|
|
host = validate_host(uri)
|
|
|
|
port = uri.port
|
|
path = uri.full_path
|
|
user = uri.user
|
|
password = uri.password
|
|
|
|
HTTP::Client.new(host, port, tls) do |client|
|
|
if user && password
|
|
client.basic_auth(user, password)
|
|
end
|
|
yield client, path
|
|
end
|
|
end
|
|
end
|
|
end
|