http-protocol 0.1.0

data/lib/http/protocol/http2/client.rb

@@ -0,0 +1,49 @@
+# Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# 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.
+
+require_relative 'connection'
+
+module HTTP
+	module Protocol
+		module HTTP2
+			class Client < Connection
+				def initialize(framer, *args)
+					super(framer, 1, *args)
+				end
+				
+				def send_connection_preface(settings = nil)
+					if @state == :new
+						@framer.write_connection_preface
+						
+						send_settings(settings)
+						
+						yield if block_given?
+						
+						read_frame do |frame|
+							raise ProtocolError, "First frame must be SettingsFrame, but got #{frame.class}" unless frame.is_a? SettingsFrame
+						end
+					else
+						raise ProtocolError, "Cannot send connection preface in state #{@state}"
+					end
+				end
+			end
+		end
+	end
+end

data/lib/http/protocol/http2/connection.rb

@@ -0,0 +1,309 @@
+# Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# 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.
+
+require_relative 'framer'
+require_relative 'flow_control'
+
+require 'http/hpack/context'
+require 'http/hpack/compressor'
+require 'http/hpack/decompressor'
+
+module HTTP
+	module Protocol
+		module HTTP2
+			class Connection
+				include FlowControl
+				
+				def initialize(framer, next_stream_id)
+					@state = :new
+					@streams = {}
+					
+					@framer = framer
+					@next_stream_id = next_stream_id
+					@last_stream_id = 0
+					
+					@local_settings = PendingSettings.new
+					@remote_settings = Settings.new
+					
+					@decoder = HPACK::Context.new
+					@encoder = HPACK::Context.new
+					
+					@local_window = Window.new(@local_settings.initial_window_size)
+					@remote_window = Window.new(@remote_settings.initial_window_size)
+				end
+				
+				def id
+					0
+				end
+				
+				def maximum_frame_size
+					@remote_settings.maximum_frame_size
+				end
+				
+				def maximum_concurrent_streams
+					[@local_settings.maximum_concurrent_streams, @remote_settings.maximum_concurrent_streams].min
+				end
+				
+				attr :framer
+				
+				# Connection state (:new, :open, :closed).
+				attr_accessor :state
+				
+				# Current settings value for local and peer
+				attr_accessor :local_settings
+				attr_accessor :remote_settings
+				
+				# Our window for receiving data. When we receive data, it reduces this window.
+				# If the window gets too small, we must send a window update.
+				attr :local_window
+				
+				# Our window for sending data. When we send data, it reduces this window.
+				attr :remote_window
+				
+				def closed?
+					@state == :closed
+				end
+				
+				def encode_headers(headers, buffer = String.new.b)
+					HPACK::Compressor.new(buffer, @encoder).encode(headers)
+					
+					return buffer
+				end
+				
+				def decode_headers(data)
+					HPACK::Decompressor.new(data, @decoder).decode
+				end
+				
+				# Streams are identified with an unsigned 31-bit integer.  Streams initiated by a client MUST use odd-numbered stream identifiers; those initiated by the server MUST use even-numbered stream identifiers.  A stream identifier of zero (0x0) is used for connection control messages; the stream identifier of zero cannot be used to establish a new stream.
+				def next_stream_id
+					id = @next_stream_id
+					
+					@next_stream_id += 2
+					
+					return id
+				end
+				
+				attr :streams
+				
+				def read_frame
+					frame = @framer.read_frame
+					# puts "#{self.class} #{@state} read_frame: #{frame.inspect}"
+					
+					yield frame if block_given?
+					
+					frame.apply(self)
+					
+					return frame
+				rescue ProtocolError => error
+					send_goaway(error.code || PROTOCOL_ERROR, error.message)
+					raise
+				end
+				
+				def send_settings(changes)
+					@local_settings.append(changes)
+					
+					frame = SettingsFrame.new
+					frame.pack(changes)
+					
+					write_frame(frame)
+				end
+				
+				def send_goaway(error_code = 0, message = "")
+					frame = GoawayFrame.new
+					frame.pack @last_stream_id, error_code, message
+					
+					write_frame(frame)
+					
+					@state = :closed
+				end
+				
+				def write_frame(frame)
+					# puts "#{self.class} #{@state} write_frame: #{frame.inspect}"
+					@framer.write_frame(frame)
+				end
+				
+				def send_ping(data)
+					if @state != :closed
+						frame = PingFrame.new
+						frame.pack data
+						
+						write_frame(frame)
+					else
+						raise ProtocolError, "Cannot send ping in state #{@state}"
+					end
+				end
+				
+				def update_local_settings(changes)
+					capacity = @local_settings.initial_window_size
+					@streams.each_value do |stream|
+						stream.local_window.capacity = capacity
+					end
+				end
+				
+				def update_remote_settings(changes)
+					capacity = @remote_settings.initial_window_size
+					@streams.each_value do |stream|
+						stream.remote_window.capacity = capacity
+					end
+				end
+				
+				# In addition to changing the flow-control window for streams that are not yet active, a SETTINGS frame can alter the initial flow-control window size for streams with active flow-control windows (that is, streams in the "open" or "half-closed (remote)" state).  When the value of SETTINGS_INITIAL_WINDOW_SIZE changes, a receiver MUST adjust the size of all stream flow-control windows that it maintains by the difference between the new value and the old value.
+				#
+				# @return [Boolean] whether the frame was an acknowledgement
+				def process_settings(frame)
+					if frame.acknowledgement?
+						# The remote end has confirmed the settings have been received:
+						changes = @local_settings.acknowledge
+						
+						update_local_settings(changes)
+						
+						return true
+					else
+						# The remote end is updating the settings, we reply with acknowledgement:
+						reply = frame.acknowledge
+						
+						write_frame(reply)
+						
+						changes = frame.unpack
+						@remote_settings.update(changes)
+						
+						update_remote_settings(changes)
+						
+						return false
+					end
+				end
+				
+				def open!
+					@local_window.capacity = self.local_settings.initial_window_size
+					@remote_window.capacity = self.remote_settings.initial_window_size
+					
+					@state = :open
+					
+					return self
+				end
+				
+				def receive_settings(frame)
+					if @state == :new
+						# We transition to :open when we receive acknowledgement of first settings frame:
+						open! if process_settings(frame)
+					elsif @state != :closed
+						process_settings(frame)
+					else
+						raise ProtocolError, "Cannot receive settings in state #{@state}"
+					end
+				end
+				
+				def receive_ping(frame)
+					if @state != :closed
+						unless frame.acknowledgement?
+							reply = frame.acknowledge
+							
+							write_frame(reply)
+						end
+					else
+						raise ProtocolError, "Cannot receive ping in state #{@state}"
+					end
+				end
+				
+				def receive_data(frame)
+					consume_local_window(frame)
+					
+					if stream = @streams[frame.stream_id]
+						stream.receive_data(frame)
+						
+						if stream.closed?
+							@streams.delete(stream.id)
+						end
+					else
+						raise ProtocolError, "Bad stream"
+					end
+				end
+				
+				def create_stream(stream_id = next_stream_id)
+					stream = Stream.new(self, stream_id)
+					
+					@last_stream_id = stream_id
+					
+					return stream
+				end
+				
+				def receive_headers(frame)
+					if stream = @streams[frame.stream_id]
+						stream.receive_headers(frame)
+						
+						if stream.closed?
+							@streams.delete(stream.id)
+						end
+					elsif frame.stream_id > @last_stream_id
+						if @streams.count < self.maximum_concurrent_streams
+							stream = create_stream(frame.stream_id)
+							stream.receive_headers(frame)
+							
+							@streams[stream.id] = stream
+						else
+							raise ProtocolError, "Exceeded maximum concurrent streams"
+						end
+					end
+				end
+				
+				def receive_priority(frame)
+					if stream = @streams[frame.stream_id]
+						stream.receive_priority(frame)
+					else
+						raise ProtocolError, "Bad stream"
+					end
+				end
+				
+				def receive_reset_stream(frame)
+					if stream = @streams[frame.stream_id]
+						stream.receive_reset_stream(frame)
+						
+						@streams.delete(stream.id)
+					else
+						raise ProtocolError, "Bad stream"
+					end
+				end
+				
+				def receive_window_update(frame)
+					if frame.connection?
+						super
+					elsif stream = @streams[frame.stream_id]
+						stream.receive_window_update(frame)
+					elsif frame.stream_id <= @last_stream_id
+						# The stream was closed/deleted, ignore
+					else
+						raise ProtocolError, "Cannot update window of non-existant stream: #{frame.stream_id}"
+					end
+				end
+				
+				def window_updated
+					# This is very inefficient, but workable.
+					@streams.each_value do |stream|
+						stream.window_updated unless stream.closed?
+					end
+				end
+				
+				def receive_frame(frame)
+					warn "Unhandled frame #{frame.inspect}"
+				end
+			end
+		end
+	end
+end

data/lib/http/protocol/http2/continuation_frame.rb

@@ -0,0 +1,86 @@
+# Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# 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.
+
+require_relative 'frame'
+
+module HTTP
+	module Protocol
+		module HTTP2
+			module Continued
+				def end_headers?
+					@flags & END_HEADERS
+				end
+				
+				def read(io)
+					super
+					
+					unless end_headers?
+						@continuation = ContinuationFrame.new
+						
+						@continuation.read(io)
+					end
+				end
+				
+				def write(io)
+					super
+					
+					if continuation = self.continuation
+						continuation.write(io)
+					end
+				end
+				
+				attr_accessor :continuation
+				
+				def pack(data, **options)
+					maximum_size = options[:maximum_size]
+					
+					if maximum_size and data.bytesize > maximum_size
+						clear_flags(END_HEADERS)
+						
+						super(data.byteslice(0, maximum_size), **options)
+						
+						remainder = data.byteslice(maximum_size, data.bytesize-maximum_size)
+						
+						@continuation = ContinuationFrame.new
+						@continuation.pack(remainder, maximum_size: maximum_size)
+					else
+						set_flags(END_HEADERS)
+						
+						super data, **options
+						
+						@continuation = nil
+					end
+				end
+			end
+			
+			# The CONTINUATION frame is used to continue a sequence of header block fragments. Any number of CONTINUATION frames can be sent, as long as the preceding frame is on the same stream and is a HEADERS, PUSH_PROMISE, or CONTINUATION frame without the END_HEADERS flag set.
+			#
+			# +---------------------------------------------------------------+
+			# |                   Header Block Fragment (*)                 ...
+			# +---------------------------------------------------------------+
+			#
+			class ContinuationFrame < Frame
+				include Continued
+				
+				TYPE = 0x9
+			end
+		end
+	end
+end

data/lib/http/protocol/http2/data_frame.rb

@@ -0,0 +1,64 @@
+# Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# Copyright, 2013, by Ilya Grigorik.
+# 
+# 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.
+
+require_relative 'frame'
+require_relative 'padded'
+
+module HTTP
+	module Protocol
+		module HTTP2
+			# DATA frames convey arbitrary, variable-length sequences of octets associated with a stream. One or more DATA frames are used, for instance, to carry HTTP request or response payloads.
+			# 
+			# DATA frames MAY also contain padding. Padding can be added to DATA frames to obscure the size of messages.
+			# 
+			# +---------------+
+			# |Pad Length? (8)|
+			# +---------------+-----------------------------------------------+
+			# |                            Data (*)                         ...
+			# +---------------------------------------------------------------+
+			# |                           Padding (*)                       ...
+			# +---------------------------------------------------------------+
+			#
+			class DataFrame < Frame
+				include Padded
+				
+				TYPE = 0x0
+				
+				def end_stream?
+					flag_set?(END_STREAM)
+				end
+				
+				def pack(data, *)
+					if data
+						super
+					else
+						@length = 0
+						set_flags(END_STREAM)
+					end
+				end
+				
+				def apply(connection)
+					connection.receive_data(self)
+				end
+			end
+		end
+	end
+end