protocol-http1 0.23.0 → 0.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5883f7878058a83c35d40fe91ea7e673a6abc1895d47e91dfefd57e1849861d5
-  data.tar.gz: f01fbad8aa91e32dddd541fa6a3ab184d8204a5761b6a0b2d5bd7eafd5aab717
+  metadata.gz: '0854252b3602c1271818e28024b62e1a4373521052b75ba0aa879a1f77a6e84e'
+  data.tar.gz: 2ad1603fc177c4b8493f304806a1f8baf4dc147b0f1707d463f534fb1e740a62
 SHA512:
-  metadata.gz: de91d508479206879dfded7ef4aca6ec5b211372ae8aa9d938afb97c4cb5d1804e9aefbea42d021979ce3c67ad6cf96c28f661be62e6c191219204f9ba96267e
-  data.tar.gz: 3c556ecfd10f3b20424629898b4684e6f8d56ad7415c94e3fedcac7485d5fb389141fd2fb9a9bbadd67a20d05a51286e338fc656febe145551b491781c052776
+  metadata.gz: 213525d129854f2198cb1be6be3d99a74d7add2e4a8dc57ed72d3bd1854b29535256120dfcbd735f1823d91bb6bf27fee6571d93d8e85f0031a404be99b39e01
+  data.tar.gz: 32f7a63f81f830a77839fa154b69bfa5a8dc316d579cc48e10d2a786e92806960c36821b3f53da67c3b1e90ba29394264ae76c621d7608c62a0d56224dabec1f

data/lib/protocol/http1/body/chunked.rb

@@ -12,8 +12,8 @@ module Protocol
 			class Chunked < HTTP::Body::Readable
 				CRLF = "\r\n"
 				
-				def initialize(stream, headers)
-					@stream = stream
+				def initialize(connection, headers)
+					@connection = connection
 					@finished = false
 					
 					@headers = headers
@@ -23,16 +23,16 @@ module Protocol
 				end
 				
 				def empty?
-					@stream.nil?
+					@connection.nil?
 				end
 				
 				def discard
-					if stream = @stream
-						@stream = nil
+					if connection = @connection
+						@connection = nil
 						
 						# We only close the connection if we haven't completed reading the entire body:
 						unless @finished
-							stream.close_read
+							connection.close_read
 						end
 					end
 				end
@@ -48,8 +48,8 @@ module Protocol
 				# Follows the procedure outlined in https://tools.ietf.org/html/rfc7230#section-4.1.3
 				def read
 					if !@finished
-						if @stream
-							length, _extensions = read_line.split(";", 2)
+						if @connection
+							length, _extensions = @connection.read_line.split(";", 2)
 							
 							unless length =~ VALID_CHUNK_LENGTH
 								raise BadRequest, "Invalid chunk length: #{length.inspect}"
@@ -61,15 +61,16 @@ module Protocol
 							if length == 0
 								read_trailer
 								
-								# The final chunk has been read and the stream is now closed:
-								@stream = nil
+								# The final chunk has been read and the connection is now closed:
+								@connection.receive_end_stream!
+								@connection = nil
 								@finished = true
 								
 								return nil
 							end
 							
 							# Read trailing CRLF:
-							chunk = @stream.read(length + 2)
+							chunk = @connection.read(length + 2)
 							
 							if chunk.bytesize == length + 2
 								# ...and chomp it off:
@@ -80,13 +81,13 @@ module Protocol
 								
 								return chunk
 							else
-								# The stream has been closed before we have read the requested length:
+								# The connection has been closed before we have read the requested length:
 								self.discard
 							end
 						end
 						
-						# If the stream has been closed before we have read the final chunk, raise an error:
-						raise EOFError, "Stream closed before expected length was read!"
+						# If the connection has been closed before we have read the final chunk, raise an error:
+						raise EOFError, "connection closed before expected length was read!"
 					end
 				end
 				
@@ -96,16 +97,8 @@ module Protocol
 				
 				private
 				
-				def read_line?
-					@stream.gets(CRLF, chomp: true)
-				end
-				
-				def read_line
-					read_line? or raise EOFError
-				end
-				
 				def read_trailer
-					while line = read_line?
+					while line = @connection.read_line?
 						# Empty line indicates end of trailer:
 						break if line.empty?
 						

data/lib/protocol/http1/body/fixed.rb

@@ -9,8 +9,8 @@ module Protocol
 	module HTTP1
 		module Body
 			class Fixed < HTTP::Body::Readable
-				def initialize(stream, length)
-					@stream = stream
+				def initialize(connection, length)
+					@connection = connection
 					
 					@length = length
 					@remaining = length
@@ -20,15 +20,15 @@ module Protocol
 				attr :remaining
 				
 				def empty?
-					@stream.nil? or @remaining == 0
+					@connection.nil? or @remaining == 0
 				end
 				
 				def discard
-					if stream = @stream
-						@stream = nil
+					if connection = @connection
+						@connection = nil
 						
 						if @remaining != 0
-							stream.close_read
+							connection.close_read
 						end
 					end
 				end
@@ -39,25 +39,30 @@ module Protocol
 					super
 				end
 				
-				# @raises EOFError if the stream is closed before the expected length is read.
+				# @raises EOFError if the connection is closed before the expected length is read.
 				def read
 					if @remaining > 0
-						if @stream
-							# `readpartial` will raise `EOFError` if the stream is finished, or `IOError` if the stream is closed.
-							chunk = @stream.readpartial(@remaining)
+						if @connection
+							# `readpartial` will raise `EOFError` if the connection is finished, or `IOError` if the connection is closed.
+							chunk = @connection.readpartial(@remaining)
 							
 							@remaining -= chunk.bytesize
 							
+							if @remaining == 0
+								@connection.receive_end_stream!
+								@connection = nil
+							end
+							
 							return chunk
 						end
 						
-						# If the stream has been closed before we have read the expected length, raise an error:
-						raise EOFError, "Stream closed before expected length was read!"
+						# If the connection has been closed before we have read the expected length, raise an error:
+						raise EOFError, "connection closed before expected length was read!"
 					end
 				end
 				
 				def inspect
-					"\#<#{self.class} length=#{@length} remaining=#{@remaining} state=#{@stream ? 'open' : 'closed'}>"
+					"\#<#{self.class} length=#{@length} remaining=#{@remaining} state=#{@connection ? 'open' : 'closed'}>"
 				end
 			end
 		end

data/lib/protocol/http1/body/remainder.rb

@@ -8,23 +8,25 @@ require "protocol/http/body/readable"
 module Protocol
 	module HTTP1
 		module Body
-			# A body that reads all remaining data from the stream.
+			# A body that reads all remaining data from the connection.
 			class Remainder < HTTP::Body::Readable
 				BLOCK_SIZE = 1024 * 64
 				
-				# block_size may be removed in the future. It is better managed by stream.
-				def initialize(stream)
-					@stream = stream
+				# block_size may be removed in the future. It is better managed by connection.
+				def initialize(connection)
+					@connection = connection
 				end
 				
 				def empty?
-					@stream.nil?
+					@connection.nil?
 				end
 				
 				def discard
-					if stream = @stream
-						@stream = nil
-						stream.close_read
+					if connection = @connection
+						@connection = nil
+						
+						# Ensure no further requests can be read from the connection, as we are discarding the body which may not be fully read:
+						connection.close_read
 					end
 				end
 				
@@ -35,15 +37,14 @@ module Protocol
 				end
 				
 				def read
-					@stream&.readpartial(BLOCK_SIZE)
-				rescue EOFError, IOError
-					@stream = nil
-					# I noticed that in some cases you will get EOFError, and in other cases IOError!?
-					return nil
+					@connection&.readpartial(BLOCK_SIZE)
+				rescue EOFError
+					@connection.receive_end_stream!
+					@connection = nil
 				end
 				
 				def inspect
-					"\#<#{self.class} state=#{@stream ? 'open' : 'closed'}>"
+					"\#<#{self.class} state=#{@connection ? 'open' : 'closed'}>"
 				end
 			end
 		end

data/lib/protocol/http1/connection.rb

@@ -50,10 +50,11 @@ module Protocol
 			HTTP10 = "HTTP/1.0"
 			HTTP11 = "HTTP/1.1"
 			
-			def initialize(stream, persistent = true)
+			def initialize(stream, persistent: true, state: :idle)
 				@stream = stream
 				
 				@persistent = persistent
+				@state = state
 				
 				@count = 0
 			end
@@ -70,6 +71,64 @@ module Protocol
 			# depending on the response semantics, may be reset to false anyway.
 			attr_accessor :persistent
 			
+			# The current state of the connection.
+			#
+			# ```
+			#                          ┌────────┐
+			#                          │        │
+			# ┌───────────────────────►│  idle  │
+			# │                        │        │
+			# │                        └───┬────┘
+			# │                            │
+			# │                            │ send request /
+			# │                            │ receive request
+			# │                            │
+			# │                            ▼
+			# │                        ┌────────┐
+			# │                recv ES │        │ send ES
+			# │           ┌────────────┤  open  ├────────────┐
+			# │           │            │        │            │
+			# │           ▼            └───┬────┘            ▼
+			# │      ┌──────────┐          │           ┌──────────┐
+			# │      │   half   │          │           │   half   │
+			# │      │  closed  │          │           │  closed  │
+			# │      │ (remote) │          │           │ (local)  │
+			# │      └────┬─────┘          │           └─────┬────┘
+			# │           │                │                 │
+			# │           │ send ES /      │       recv ES / │
+			# │           │ close          ▼           close │
+			# │           │            ┌────────┐            │
+			# │           └───────────►│        │◄───────────┘
+			# │                        │ closed │
+			# └────────────────────────┤        │
+			#         persistent       └────────┘
+			# ```
+			#
+			# - `ES`: the body was fully received or sent (end of stream)
+			#
+			# State transition methods use a trailing "!".
+			attr_accessor :state
+			
+			def idle?
+				@state == :idle
+			end
+			
+			def open?
+				@state == :open
+			end
+			
+			def half_closed_local?
+				@state == :half_closed_local
+			end
+			
+			def half_closed_remote?
+				@state == :half_closed_remote
+			end
+			
+			def closed?
+				@state == :closed
+			end
+			
 			# The number of requests processed.
 			attr :count
 			
@@ -130,7 +189,15 @@ module Protocol
 				@stream&.close
 			end
 			
+			def open!
+				raise ProtocolError, "Cannot write request in #{@state}!" unless @state == :idle
+				
+				@state = :open
+			end
+			
 			def write_request(authority, method, path, version, headers)
+				open!
+				
 				@stream.write("#{method} #{path} #{version}\r\n")
 				@stream.write("host: #{authority}\r\n")
 				
@@ -138,6 +205,10 @@ module Protocol
 			end
 			
 			def write_response(version, status, headers, reason = Reason::DESCRIPTIONS[status])
+				unless @state == :open or @state == :half_closed_remote
+					raise ProtocolError, "Cannot write response in #{@state}!"
+				end
+				
 				# Safari WebSockets break if no reason is given:
 				@stream.write("#{version} #{status} #{reason}\r\n")
 				
@@ -145,6 +216,10 @@ module Protocol
 			end
 			
 			def write_interim_response(version, status, headers, reason = Reason::DESCRIPTIONS[status])
+				unless @state == :open or @state == :half_closed_remote
+					raise ProtocolError, "Cannot write interim response in #{@state}!"
+				end
+				
 				@stream.write("#{version} #{status} #{reason}\r\n")
 				
 				write_headers(headers)
@@ -173,6 +248,14 @@ module Protocol
 				end
 			end
 			
+			def readpartial(length)
+				@stream.readpartial(length)
+			end
+			
+			def read(length)
+				@stream.read(length)
+			end
+			
 			def read_line?
 				@stream.gets(CRLF, chomp: true)
 			end
@@ -181,6 +264,10 @@ module Protocol
 				read_line? or raise EOFError
 			end
 			
+			def close_read
+				@stream.close_read
+			end
+			
 			def read_request_line
 				return unless line = read_line?
 				
@@ -194,6 +281,8 @@ module Protocol
 			end
 			
 			def read_request
+				open!
+				
 				method, path, version = read_request_line
 				return unless method
 				
@@ -203,6 +292,10 @@ module Protocol
 				
 				body = read_request_body(method, headers)
 				
+				unless body
+					self.receive_end_stream!
+				end
+				
 				@count += 1
 				
 				return headers.delete(HOST), method, path, version, headers, body
@@ -216,16 +309,30 @@ module Protocol
 				return version, status, reason
 			end
 			
+			private def interim_status?(status)
+				status != 101 and status >= 100 and status < 200
+			end
+			
 			def read_response(method)
+				unless @state == :open or @state == :half_closed_local
+					raise ProtocolError, "Cannot read response in #{@state}!"
+				end
+				
 				version, status, reason = read_response_line
 				
 				headers = read_headers
 				
 				@persistent = persistent?(version, method, headers)
 				
-				body = read_response_body(method, status, headers)
-				
-				@count += 1
+				unless interim_status?(status)
+					body = read_response_body(method, status, headers)
+					
+					unless body
+						self.receive_end_stream!
+					end
+					
+					@count += 1
+				end
 				
 				return version, status, reason, headers, body
 			end
@@ -383,6 +490,32 @@ module Protocol
 				@stream.close_write
 			end
 			
+			def idle!
+				@state = :idle
+			end
+			
+			def closed!
+				unless @state == :half_closed_local or @state == :half_closed_remote
+					raise ProtocolError, "Cannot close in #{@state}!" 
+				end
+				
+				if @persistent
+					self.idle!
+				else
+					@state = :closed
+				end
+			end
+			
+			def send_end_stream!
+				if @state == :open
+					@state = :half_closed_local
+				elsif @state == :half_closed_remote
+					self.closed!
+				else
+					raise ProtocolError, "Cannot send end stream in #{@state}!"
+				end
+			end
+			
 			def write_body(version, body, head = false, trailer = nil)
 				# HTTP/1.0 cannot in any case handle trailers.
 				if version == HTTP10 # or te: trailers was not present (strictly speaking not required.)
@@ -412,22 +545,37 @@ module Protocol
 					write_connection_header(version)
 					write_body_and_close(body, head)
 				end
+			ensure
+				send_end_stream!
+			end
+			
+			def receive_end_stream!
+				if @state == :open
+					@state = :half_closed_remote
+				elsif @state == :half_closed_local
+					self.closed!
+				else
+					raise ProtocolError, "Cannot receive end stream in #{@state}!"
+				end
 			end
 			
 			def read_chunked_body(headers)
-				Body::Chunked.new(@stream, headers)
+				Body::Chunked.new(self, headers)
 			end
 			
 			def read_fixed_body(length)
-				Body::Fixed.new(@stream, length)
+				Body::Fixed.new(self, length)
 			end
 			
 			def read_remainder_body
 				@persistent = false
-				Body::Remainder.new(@stream)
+				Body::Remainder.new(self)
 			end
 			
 			def read_head_body(length)
+				# We are not receiving any body:
+				self.receive_end_stream!
+				
 				Protocol::HTTP::Body::Head.new(length)
 			end
 			

data/lib/protocol/http1/error.rb

@@ -10,6 +10,10 @@ module Protocol
 		class Error < HTTP::Error
 		end
 		
+		# The protocol was violated in some way, e.g. trying to write a request while reading a response.
+		class ProtocolError < Error
+		end
+		
 		# The request was not able to be parsed correctly, or failed some kind of validation.
 		class BadRequest < Error
 		end

data/lib/protocol/http1/version.rb

@@ -5,6 +5,6 @@
 
 module Protocol
 	module HTTP1
-		VERSION = "0.23.0"
+		VERSION = "0.24.0"
 	end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: protocol-http1
 version: !ruby/object:Gem::Version
-  version: 0.23.0
+  version: 0.24.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -42,7 +42,7 @@ cert_chain:
   Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
   voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
   -----END CERTIFICATE-----
-date: 2024-09-17 00:00:00.000000000 Z
+date: 2024-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: protocol-http