eventmachine-win32 0.5.3 → 0.7.0

data/lib/protocols/header_and_content.rb

@@ -0,0 +1,134 @@
+# $Id: header_and_content.rb 281 2006-11-20 03:17:22Z blackhedd $
+#
+# Author:: blackhedd (gmail address: garbagecat10).
+# Date:: 15 November 2006
+# 
+# Copyright (C) 2006 by Francis Cianfrocca. All Rights Reserved.
+#
+# This program is made available under the terms of the GPL version 2.
+#
+# See EventMachine and EventMachine::Connection for documentation and
+# usage examples.
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006 by Francis Cianfrocca. All Rights Reserved.
+#
+# Gmail: garbagecat10
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+#---------------------------------------------------------------------------
+#
+# 
+
+
+
+module EventMachine
+    module Protocols
+
+	class HeaderAndContentProtocol < LineAndTextProtocol
+
+	    ContentLengthPattern = /Content-length:\s*(\d+)/i
+
+	    def initialize *args
+		super
+		init_for_request
+	    end
+
+	    def receive_line line
+		case @hc_mode
+		when :discard_blanks
+		    unless line == ""
+			@hc_mode = :headers
+			receive_line line
+		    end
+		when :headers
+		    if line == ""
+			raise "unrecognized state" unless @hc_headers.length > 0
+			if respond_to?(:receive_headers)
+			    receive_headers @hc_headers
+			end
+			# @hc_content_length will be nil, not 0, if there was no content-length header.
+			if @hc_content_length.to_i > 0
+			    set_binary_mode @hc_content_length
+			else
+			    dispatch_request
+			end
+		    else
+			@hc_headers << line
+			if ContentLengthPattern =~ line
+			    # There are some attacks that rely on sending multiple content-length
+			    # headers. This is a crude protection, but needs to become tunable.
+			    raise "extraneous content-length header" if @hc_content_length
+			    @hc_content_length = $1.to_i
+			end
+			if @hc_headers.length == 1 and respond_to?(:receive_first_header_line)
+			    receive_first_header_line line
+			end
+		    end
+		else
+		    raise "internal error, unsupported mode"
+		end
+	    end
+
+	    def receive_binary_data text
+		@hc_content = text
+		dispatch_request
+	    end
+
+	    def dispatch_request
+		if respond_to?(:receive_request)
+		    receive_request @hc_headers, @hc_content
+		end
+		init_for_request
+	    end
+	    private :dispatch_request
+
+	    def init_for_request
+		@hc_mode = :discard_blanks
+		@hc_headers = []
+		# originally was @hc_headers ||= []; @hc_headers.clear to get a performance
+		# boost, but it's counterproductive because a subclassed handler will have to
+		# call dup to use the header array we pass in receive_headers.
+
+		@hc_content_length = nil
+		@hc_content = ""
+	    end
+	    private :init_for_request
+
+	    # Basically a convenience method. We might create a subclass that does this
+	    # automatically. But it's such a performance killer.
+	    def headers_2_hash hdrs
+		self.class.headers_2_hash hdrs
+	    end
+
+	    class << self
+		def headers_2_hash hdrs
+		    hash = {}
+		    hdrs.each {|h|
+			if /\A([^\s:]+)\s*:\s*/ =~ h
+			    tail = $'.dup
+			    hash[ $1.downcase.gsub(/-/,"_").intern ] = tail
+			end
+		    }
+		    hash
+		end
+	    end
+
+	end
+    end
+end
+

data/lib/protocols/httpclient.rb

@@ -0,0 +1,233 @@
+# $Id: httpclient.rb 226 2006-08-10 08:55:49Z blackhedd $
+#
+# Author:: blackhedd (gmail address: garbagecat10).
+# Date:: 16 July 2006
+# 
+# Copyright (C) 2006 by Francis Cianfrocca. All Rights Reserved.
+#
+# This program is made available under the terms of the GPL version 2.
+#
+# See EventMachine and EventMachine::Connection for documentation and
+# usage examples.
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006 by Francis Cianfrocca. All Rights Reserved.
+#
+# Gmail: garbagecat10
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+#---------------------------------------------------------------------------
+#
+# 
+
+
+
+module EventMachine
+module Protocols
+
+class HttpClient < Connection
+  include EventMachine::Deferrable
+
+
+  # USAGE SAMPLE:
+  # WARNING, POST is not yet supported!!!!!
+  #
+  # EventMachine.run {
+  #   http = EventMachine::Protocols::HttpClient.request(
+  #     :host => server,
+  #     :port => 80,
+  #     :request => "/index.html",
+  #     :query_string => "parm1=value1&parm2=value2"
+  #   )
+  #   http.callback {|response|
+  #     puts response[:status]
+  #     puts response[:headers]
+  #     puts response[:content]
+  #   }
+  # }
+  #
+
+  # TODO:
+  # POST REQUESTS!!!!!!!!!!!
+  # Timeout for connections that run too long or hang somewhere in the middle.
+  # Persistent connections (HTTP/1.1), may need a associated delegate object.
+  # DNS: Some way to cache DNS lookups for hostnames we connect to. Ruby's
+  # DNS lookups are unbelievably slow.
+  # HEAD requests.
+  # Chunked transfer encoding.
+  # Convenience methods for requests. get, post, url, etc.
+  # SSL.
+  # Handle status codes like 304, 100, etc.
+  # Refactor this code so that protocol errors all get handled one way (an exception?),
+  # instead of sprinkling set_deferred_status :failed calls everywhere.
+
+  def self.request( args = {} )
+    args[:port] ||= 80
+    EventMachine.connect( args[:host], args[:port], self ) {|c|
+      # According to the docs, we will get here AFTER post_init is called.
+      c.instance_eval {@args = args}
+    }
+  end
+
+  def post_init
+    @start_time = Time.now
+    @data = ""
+    @read_state = :base
+  end
+
+  # We send the request when we get a connection.
+  # AND, we set an instance variable to indicate we passed through here.
+  # That allows #unbind to know whether there was a successful connection.
+  # NB: This naive technique won't work when we have to support multiple
+  # requests on a single connection.
+  def connection_completed
+    @connected = true
+    send_request @args
+  end
+
+  def send_request args
+    args[:verb] ||= :get # IS THIS A GOOD IDEA, to default to GET if nothing was specified?
+
+    verb = args[:verb].to_s.upcase
+    unless ["GET", "POST", "HEAD"].include?(verb)
+      set_deferred_status :failed, {:status => 0} # TODO, not signalling the error type
+      return # NOTE THE EARLY RETURN, we're not sending any data.
+    end
+
+    request = args[:request] || "/"
+    unless request[0,1] == "/"
+      request = "/" + request
+    end
+
+    qs = args[:query_string] || ""
+    if qs.length > 0 and qs[0,1] != '?'
+      qs = "?" + qs
+    end
+
+    # Allow an override for the host header if it's not the connect-string.
+    host = args[:host_header] || args[:host] || "_"
+
+    # ESSENTIAL for the request's line-endings to be CRLF, not LF. Some servers misbehave otherwise.
+    req = [
+      "#{verb} #{request}#{qs} HTTP/1.1",
+      "Host: #{host}",
+      "User-agent: Ruby EventMachine",
+      ""
+    ].map {|l| "#{l}\r\n"}.join
+
+    send_data req
+  end
+
+
+  def receive_data data
+    while data and data.length > 0
+      case @read_state
+      when :base
+        # Perform any per-request initialization here and don't consume any data.
+        @data = ""
+        @headers = []
+        @content_length = nil # not zero
+        @content = ""
+        @status = nil
+        @read_state = :header
+      when :header
+        ary = data.split( /\r?\n/m, 2 )
+        if ary.length == 2
+          data = ary.last
+          if ary.first == ""
+            @read_state = :content
+          else
+            @headers << ary.first
+            if @headers.length == 1
+              parse_response_line
+            elsif ary.first =~ /\Acontent-length:\s*/i
+              # Only take the FIRST content-length header that appears,
+              # which we can distinguish because @content_length is nil.
+              # TODO, it's actually a fatal error if there is more than one
+              # content-length header, because the caller is presumptively
+              # a bad guy. (There is an exploit that depends on multiple
+              # content-length headers.)
+              @content_length ||= $'.to_i
+            end
+          end
+        else
+          @data << data
+          data = ""
+        end
+      when :content
+        # If there was no content-length header, we have to wait until the connection
+        # closes. Everything we get until that point is content.
+        # TODO: Must impose a content-size limit, and also must implement chunking.
+        # Also, must support either temporary files for large content, or calling
+        # a content-consumer block supplied by the user.
+        if @content_length
+          bytes_needed = @content_length - @content.length
+          @content += data[0, bytes_needed]
+          data = data[bytes_needed..-1] || ""
+          if @content_length == @content.length
+            dispatch_response
+            @read_state = :base
+          end
+        else
+          @content << data
+          data = ""
+        end
+      end
+    end
+  end
+
+
+  # We get called here when we have received an HTTP response line.
+  # It's an opportunity to throw an exception or trigger other exceptional
+  # handling.
+  def parse_response_line
+    if @headers.first =~ /\AHTTP\/1\.[01] ([\d]{3})/
+      @status = $1.to_i
+    else
+      set_deferred_status :failed, {
+        :status => 0 # crappy way of signifying an unrecognized response. TODO, find a better way to do this.
+      }
+      close_connection
+    end
+  end
+  private :parse_response_line
+
+  def dispatch_response
+    @read_state = :base
+    set_deferred_status :succeeded, {
+      :content => @content,
+      :headers => @headers,
+      :status => @status
+    }
+    # TODO, we close the connection for now, but this is wrong for persistent clients.
+    close_connection
+  end
+
+  def unbind
+    if !@connected
+      set_deferred_status :failed, {:status => 0} # YECCCCH. Find a better way to signal no-connect/network error.
+    elsif (@read_state == :content and @content_length == nil)
+      dispatch_response
+    end
+  end
+end
+
+
+end
+end
+
+

data/lib/protocols/line_and_text.rb

@@ -0,0 +1,141 @@
+# $Id: line_and_text.rb 279 2006-11-18 15:40:25Z blackhedd $
+#
+# Author:: blackhedd (gmail address: garbagecat10).
+# Date:: 15 November 2006
+# 
+# Copyright (C) 2006 by Francis Cianfrocca. All Rights Reserved.
+#
+# This program is made available under the terms of the GPL version 2.
+#
+# See EventMachine and EventMachine::Connection for documentation and
+# usage examples.
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006 by Francis Cianfrocca. All Rights Reserved.
+#
+# Gmail: garbagecat10
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+#---------------------------------------------------------------------------
+#
+# 
+
+
+
+module EventMachine
+    module Protocols
+
+	class LineAndTextProtocol < Connection
+	    MaxLineLength = 16*1024
+	    MaxBinaryLength = 32*1024*1024
+
+	    def initialize *args
+		super
+		lbp_init_line_state
+	    end
+	    def receive_data data
+		if @lbp_mode == :lines
+		    @lbp_data << data
+		    while i = @lbp_data.index("\n")
+			# line-length test is provisional. Need to be tunable and do something
+			# more intelligent than throwing something.
+			if i > MaxLineLength
+			    receive_error("overlength line") if respond_to?(:receive_error)
+			    close_connection
+			    break # exit the while loop
+			end
+			line = @lbp_data.slice!(0..i).chomp
+			receive_line line if respond_to?(:receive_line)
+		    end
+		else
+		    if @lbp_binary_limit > 0
+			wanted = @lbp_binary_limit - @lbp_binary_bytes_received
+			chunk = nil
+			if data.length > wanted
+			    chunk = data.slice!(0...wanted)
+			else
+			    chunk = data
+			    data = ""
+			end
+			@lbp_binary_buffer[@lbp_binary_bytes_received...(@lbp_binary_bytes_received+chunk.length)] = chunk
+			@lbp_binary_bytes_received += chunk.length
+			if @lbp_binary_bytes_received == @lbp_binary_limit
+			    receive_binary_data(@lbp_binary_buffer) if respond_to?(:receive_binary_data)
+			    lbp_init_line_state
+			end
+			receive_data(data) if data.length > 0
+		    else
+			receive_binary_data(data) if respond_to?(:receive_binary_data)
+			data = ""
+		    end
+		end
+	    end
+
+	    def unbind
+		if @lbp_mode == :binary and @lbp_binary_limit > 0
+		    if respond_to?(:receive_binary_data)
+			receive_binary_data( @lbp_binary_buffer[0...@lbp_binary_bytes_received] )
+		    end
+		end
+	    end
+
+	    # Set up to read the supplied number of binary bytes.
+	    # This recycles all the data currently waiting in the line buffer, if any.
+	    # If the limit is nil, then ALL subsequent data will be treated as binary
+	    # data and passed to the upstream protocol handler as we receive it.
+	    # If a limit is given, we'll hold the incoming binary data and not
+	    # pass it upstream until we've seen it all, or until there is an unbind
+	    # (in which case we'll pass up a partial).
+	    # Specifying nil for the limit (the default) means there is no limit.
+	    # Specifiyng zero for the limit will cause an immediate transition back to line mode.
+	    #
+	    def set_binary_mode size = nil
+		if @lbp_mode == :lines
+		    if size == 0
+			receive_binary_data("") if respond_to?(:receive_binary_data)
+			# Do no more work here. Stay in line mode and keep consuming data.
+		    else
+			@lbp_binary_limit = size.to_i # (nil will be stored as zero)
+			if @lbp_binary_limit > 0
+			    raise "Overlength" if @lbp_binary_limit > MaxBinaryLength # arbitrary sanity check
+			    @lbp_binary_buffer = "\0" * @lbp_binary_limit
+			    @lbp_binary_bytes_received = 0
+			end
+
+			@lbp_mode = :binary
+			if @lbp_data.length > 0
+			    d,@lbp_data = @lbp_data,""
+			    receive_data d
+			end
+		    end
+		else
+		    raise "invalid operation"
+		end
+	    end
+
+	    #--
+	    # For internal use, establish protocol baseline for handling lines.
+	    def lbp_init_line_state
+		@lbp_data = ""
+		@lbp_mode = :lines
+	    end
+	    private :lbp_init_line_state
+
+	end
+    end
+end
+