rffw 0.0.1

data/lib/rffw/app/view_helpers.rb

@@ -0,0 +1,30 @@
+module RFFW::App::ViewHelpers
+  
+  CHARS = File.read(File.expand_path('../urlencode_chars.data',__FILE__)).split("\n")
+  
+  def uri_escape(string)
+    string.gsub(/[^a-zA-Z0-9 ]/) do |char|
+      CHARS.include?(char) ? "%#{"%.2X" % (CHARS.index(char)+32)}" : char
+    end.tr(" ", "+")
+  end
+
+  def uri_unescape(string)
+    string.gsub(/\%([a-f0-9]{2})/i) do |char|
+      value = $1.to_i(16)
+      case value
+      when 32..(CHARS.size+32)
+        CHARS[value - 32] || char
+      when 13
+        "\n"
+      when 10
+        '' #LF
+      else
+        "#{char}"
+      end
+    end.gsub("+", " ")
+  end
+  
+  def strip_tags(string)
+    string.gsub(/<(.|\n)*?>/m, '')
+  end
+end

data/lib/rffw/parser.rb

@@ -0,0 +1,9 @@
+
+
+module RFFW
+  module Parser
+    require 'rffw/parser/http_request'
+    require 'rffw/parser/http_response'
+    require 'rffw/parser/mime_parser'
+  end
+end

data/lib/rffw/parser/http_request.rb

@@ -0,0 +1,137 @@
+module RFFW::Parser
+  class HttpRequest
+
+    class MalformedReqest < StandardError ; end
+    class IncompleteRequest < StandardError ; end
+    class OnlyForPosts < StandardError; end
+    
+    attr_reader :headers
+
+    def initialize(raw_request)
+      @headers={}
+      @headers_are_parsed = false
+      scan(raw_request)
+    rescue IncompleteRequest
+
+    end
+
+    def finish?
+      if get? && @headers_are_parsed
+        true
+      elsif post? && @headers_are_parsed && upload_content_lenght <= body_size
+        true
+      else
+        false
+      end
+    end
+    
+    def body
+      post? ? @body : @body || ""
+    end
+
+    def attachments
+      raise OnlyForPosts unless post?
+      MimeParser.parse(@body)
+    end
+
+    def method
+      @headers["HTTP_METHOD"]
+    end
+
+    def path
+      uri && uri.path
+    end
+
+    def query
+      uri && uri.query || ""
+    end
+
+    def url
+      @headers["HTTP_PATH"]
+    end
+
+    def uri
+      URI.parse(url)
+    rescue
+      nil
+    end
+
+    def version
+      @headers["HTTP_VERSION"]
+    end
+
+    def keep_alive?
+      !!(version == '1.1' && @headers["Connection"] =~ /keep-alive/)
+    end
+
+    def post?
+      method && method.downcase == "post"
+    end
+
+    def get?
+      method && method.downcase == 'get'
+    end
+
+    def uplad_info
+      @headers["Content-Length"].to_i - @body.size
+    end
+
+    def upload_content_lenght
+      raise OnlyForPosts unless post?
+      @headers["Content-Length"].to_i
+    end
+
+    def body_size
+      raise OnlyForPosts unless post?
+      @body.size
+    end
+
+    def upload_progress
+      raise OnlyForPosts unless post?
+      "#{body_size}/#{upload_content_lenght}"
+    end
+
+
+    def post_form_data
+      body.split("&").inject({}){|memo, value|
+        key,value = value.split("=")
+        memo[key] = value
+        memo
+      }
+    end
+    
+    def inspect
+      "#{method} #{path} #{query} #{version}"
+    end
+
+  protected
+    def scan(raw)
+      return nil unless raw.is_a?(String)
+      full_scanner = StringScanner.new(raw.force_encoding("BINARY"))
+      
+      headers = full_scanner.scan_until(/\r\n\r\n/) or raise IncompleteRequest
+      scan_headers(headers)
+      
+      @body = full_scanner.rest
+    end
+
+    def scan_headers(headers)
+      scanner = StringScanner.new(headers)
+      
+      @headers["HTTP_METHOD"] = scanner.scan(/\w+/) or raise MalformedReqest
+      scanner.scan(/\s+/)
+      @headers["HTTP_PATH"] = scanner.scan(/\S+/) or raise MalformedReqest
+      scanner.scan(/\s+HTTP\//) or raise MalformedReqest
+      @headers["HTTP_VERSION"] = scanner.scan(/\S+/) or raise MalformedReqest
+      begin
+        scanner.scan(/\r\n/)
+        break if scanner.scan(/\r\n/) || scanner.eos?
+        key = scanner.scan(/\A[^:]+/) or break
+        scanner.scan(/\:\s*/) or break
+        value = scanner.scan(/.*\r\n/) or break
+        @headers[key] = value.strip if key && value
+      end while (key && value)
+      @headers_are_parsed = true
+    end
+  end
+end

data/lib/rffw/parser/http_response.rb

@@ -0,0 +1,29 @@
+module RFFW::Parser
+  class HttpResponse
+
+    def initialize(message, status = 200, headers = {"Content-Type" => 'text/html'}, version = "1.1" )
+      @message, @status, @headers, @version = message, status, headers, version
+    end
+
+    def to_s
+      headers = @headers.map{|k,v|
+        "#{k}: #{v}\r\n"
+      }.join('')
+      
+      response = ""
+      response << "HTTP/#{@version} #{@status.to_s}\r\n"
+      response << "Server: rffw/#{RFFW::VERSION}\r\n"
+      response << "Date: #{Time.now.httpdate}\r\n"
+      response << headers
+      
+      if @headers["Transfer-Encoding"] && @headers["Transfer-Encoding"] == "chunked"
+        response << "\r\n"
+      else
+        response << "Content-Length: #{@message.size}\r\n" <<
+        "\r\n#{@message}"
+      end
+      response
+    end
+    
+  end
+end

data/lib/rffw/parser/mime_parser.rb

@@ -0,0 +1,46 @@
+module RFFW::Parser
+  module MimeParser
+    extend self
+    class Attachment < Struct.new(:boundary, :header, :data, :headers)
+
+      def header=(header)
+        return if header.nil?
+        @headers = {}
+        header.split("\r\n").each{|l| 
+          head = l.split(":") 
+          @headers[head[0]] = head[1].strip
+        }
+      end
+
+      def content_disposition
+        @headers.find{|k,v| k.downcase == 'content-disposition' }.last
+      end
+      
+      def content_type
+        @headers.find{|k,v| k.downcase == 'content-type' }.last
+      end
+      
+      def filename
+        content_disposition[/filename\=\"([^"]*)\"/i,1]
+      end
+      
+      def to_s
+        data
+      end
+    end
+    def parse(string)
+      scanner = StringScanner.new(string.force_encoding("BINARY"))
+      attachments = []
+      while !scanner.eos?
+        attachment = Attachment.new
+        attachment.boundary = scanner.scan_until(/\r\n/).strip
+        attachment.header = scanner.scan_until(/\r\n\r\n/)
+        pos = scanner.pos
+        scanner.scan_until(/\r\n#{Regexp.escape attachment.boundary}/)
+        attachment.data = scanner.pre_match.to_s[pos..-1]
+          attachments << attachment unless attachment.data.nil?
+      end
+      attachments
+    end
+  end
+end

data/lib/rffw/server.rb

@@ -0,0 +1,15 @@
+require 'socket'
+require 'delegate'
+require 'tempfile'
+require 'time'
+require 'strscan'
+require 'uri'
+
+module RFFW
+  module Server
+    require 'rffw/server/client'
+    require 'rffw/server/buffered_client'
+    require 'rffw/server/http_client'
+    require 'rffw/server/server'
+  end
+end

data/lib/rffw/server/buffered_client.rb

@@ -0,0 +1,57 @@
+module RFFW::Server
+  class BufferedClient < Client
+    
+    @@buffer_size = 1024
+
+    def initialize(*args)
+      super
+      @buffer = ''
+      @file = nil
+    end
+
+    def on_data
+      data = self.read_nonblock 1024*1024*1024
+      if !@file && @buffer.size + data.size > @@buffer_size
+        @file = Tempfile.new('rffw_request')
+        @file.write @buffer
+        @file.write data
+        @buffer = nil
+      elsif @file
+        @file.write data
+      else
+        @buffer << data
+      end
+    end
+    
+    def usign_temp_file?
+      !!@file
+    end
+    
+    def buffer_io
+      usign_temp_file? ? @file : @buffer
+    end
+    
+    def on_disconnect
+      clear_buffer
+      super
+    end
+    
+    def buffer
+      if @file
+        @file.rewind
+        @file.read
+      else
+        @buffer
+      end
+    end
+    
+    def clear_buffer
+      if @file
+        @file.close
+        @file.unlink
+        @file = nil
+      end
+      @buffer = ''
+    end
+  end
+end

data/lib/rffw/server/client.rb

@@ -0,0 +1,53 @@
+module RFFW::Server
+
+  class Client < DelegateClass(TCPSocket)
+    extend Enumerable
+
+    @@clients = []
+
+    def initialize(socket)
+      Thread.exclusive {
+        @@clients << self
+      }
+      super(socket)
+    end
+
+    def self.all
+      Thread.exclusive {
+        @@clients.uniq!
+      }
+      @@clients
+    end
+
+    def self.each(&block)
+      @@clients.each(&block)
+    end
+
+    def self.find(client)
+      @@clients.find{|c| c == client}
+    end
+
+    def self.find_by_io(client)
+      @@clients.find{ |c| c.to_i == client.to_i }
+    end
+
+    def self.disconnect_all!
+      while client = Thread.exclusive{@@clients.pop}
+        client.on_disconnect 
+      end
+    end
+
+    def finished?
+      return  ((closed? || eof?) ? true : false)
+    rescue Errno::ECONNRESET
+      return true
+    end
+
+    def on_disconnect
+      close unless closed?
+      Thread.exclusive{ @@clients.delete self }
+    end
+
+    alias disconnect! on_disconnect
+  end
+end

data/lib/rffw/server/http_client.rb

@@ -0,0 +1,49 @@
+module RFFW::Server
+  class HttpClient < BufferedClient
+    include RFFW::Parser
+    attr_reader :request
+
+    def initialize(*args)
+      super
+    end
+
+    def on_data
+      super
+      @request = process_request(self.buffer)
+      on_request(request) if @request.finish?
+    end
+
+    def on_request(request)
+      message = "Not found"
+      write ["HTTP/1.1 404 Not found",
+      "Server: rffw/#{RFFW::VERSION}",
+      "Date: #{Time.now.httpdate}",
+      "Content-Type: text/html",
+      "Content-Length: #{message.size}",
+      "Last-Modified: #{Time.now.httpdate}",
+      "Connection: keep-alive",
+      "Accept-Ranges: bytes",
+      "",
+      "#{message}"].join("\r\n")
+    end
+
+    def write_chunk(message)
+      unless defined?(@headers_sent) && @headers_sent == true
+        write HttpResponse.new("", 200, {"Transfer-Encoding" => "chunked"},'1.1')
+        @headers_sent = true
+      end
+      write generate_chunk(message)
+    end
+
+    protected
+
+    def generate_chunk(text)
+      "#{text.size.to_s(16).upcase}\r\n#{text}\r\n\r\n"
+    end
+
+    def process_request(raw_request)
+      HttpRequest.new(raw_request)
+    end
+
+  end
+end

data/lib/rffw/server/server.rb

@@ -0,0 +1,46 @@
+module RFFW::Server
+  class Server < TCPServer
+    include RFFW::Server
+
+    def initialize(handler = HttpClient, port = 8080, listen = "0.0.0.0" )
+      @handler = handler
+      super(listen,port)
+      catch :ctrl_c do 
+        loop do
+          read, write, error = Kernel.select(@handler.all << self)
+          read.each do |io|
+            io == self ? process_server : process_client(io)
+          end
+        end
+      end
+    end
+    
+    private
+    
+    def process_server
+      begin
+        socket = accept_nonblock
+        @handler.new(socket)
+      rescue Errno::EAGAIN
+      end
+    end
+    
+    def process_client(io)
+      begin
+        if client = @handler.find_by_io(io)
+          client.finished? ? client.on_disconnect : client.on_data
+        else
+          raise "Sorry. I don't know how to manage this situation"
+        end
+      rescue IOError => e
+        $stderr.puts "Closed Stream"
+        client.disconnect!
+      rescue => e
+        client.disconnect!
+        $stderr.puts e.inspect
+        $stderr.puts e.backtrace
+      end
+    end
+    
+  end
+end