shoesgem 0.1424.0

data/shoes/ruby/lib/webrick/server.rb

@@ -0,0 +1,210 @@
+#
+# server.rb -- GenericServer Class
+#
+# Author: IPR -- Internet Programming with Ruby -- writers
+# Copyright (c) 2000, 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
+# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
+# reserved.
+#
+# $IPR: server.rb,v 1.62 2003/07/22 19:20:43 gotoyuzo Exp $
+
+require 'thread'
+require 'socket'
+require 'webrick/config'
+require 'webrick/log'
+
+module WEBrick
+
+  class ServerError < StandardError; end
+
+  class SimpleServer
+    def SimpleServer.start
+      yield
+    end
+  end
+
+  class Daemon
+    def Daemon.start
+      exit!(0) if fork
+      Process::setsid
+      exit!(0) if fork
+      Dir::chdir("/")
+      File::umask(0)
+      STDIN.reopen("/dev/null")
+      STDOUT.reopen("/dev/null", "w")
+      STDERR.reopen("/dev/null", "w")
+      yield if block_given?
+    end
+  end
+
+  class GenericServer
+    attr_reader :status, :config, :logger, :tokens, :listeners
+
+    def initialize(config={}, default=Config::General)
+      @config = default.dup.update(config)
+      @status = :Stop
+      @config[:Logger] ||= Log::new
+      @logger = @config[:Logger]
+
+      @tokens = SizedQueue.new(@config[:MaxClients])
+      @config[:MaxClients].times{ @tokens.push(nil) }
+
+      webrickv = WEBrick::VERSION
+      rubyv = "#{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}]"
+      @logger.info("WEBrick #{webrickv}")
+      @logger.info("ruby #{rubyv}")
+
+      @listeners = []
+      unless @config[:DoNotListen]
+        if @config[:Listen]
+          warn(":Listen option is deprecated; use GenericServer#listen")
+        end
+        listen(@config[:BindAddress], @config[:Port])
+        if @config[:Port] == 0
+          @config[:Port] = @listeners[0].addr[1]
+        end
+      end
+    end
+
+    def [](key)
+      @config[key]
+    end
+
+    def listen(address, port)
+      @listeners += Utils::create_listeners(address, port, @logger)
+    end
+
+    def start(&block)
+      raise ServerError, "already started." if @status != :Stop
+      server_type = @config[:ServerType] || SimpleServer
+
+      server_type.start{
+        @logger.info \
+          "#{self.class}#start: pid=#{$$} port=#{@config[:Port]}"
+        call_callback(:StartCallback)
+
+        thgroup = ThreadGroup.new
+        @status = :Running
+        while @status == :Running
+          begin
+            if svrs = IO.select(@listeners, nil, nil, 2.0)
+              svrs[0].each{|svr|
+                @tokens.pop          # blocks while no token is there.
+                if sock = accept_client(svr)
+                  sock.do_not_reverse_lookup = config[:DoNotReverseLookup]
+                  th = start_thread(sock, &block)
+                  th[:WEBrickThread] = true
+                  thgroup.add(th)
+                else
+                  @tokens.push(nil)
+                end
+              }
+            end
+          rescue Errno::EBADF, IOError => ex
+            # if the listening socket was closed in GenericServer#shutdown,
+            # IO::select raise it.
+          rescue Exception => ex
+            msg = "#{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}"
+            @logger.error msg
+          end
+        end
+
+        @logger.info "going to shutdown ..."
+        thgroup.list.each{|th| th.join if th[:WEBrickThread] }
+        call_callback(:StopCallback)
+        @logger.info "#{self.class}#start done."
+        @status = :Stop
+      }
+    end
+
+    def stop
+      if @status == :Running
+        @status = :Shutdown
+      end
+    end
+
+    def shutdown
+      stop
+      @listeners.each{|s|
+        if @logger.debug?
+          addr = s.addr
+          @logger.debug("close TCPSocket(#{addr[2]}, #{addr[1]})")
+        end
+        begin
+          s.shutdown
+        rescue Errno::ENOTCONN
+          # when `Errno::ENOTCONN: Socket is not connected' on some platforms,
+          # call #close instead of #shutdown.
+          # (ignore @config[:ShutdownSocketWithoutClose])
+          s.close
+        else
+          unless @config[:ShutdownSocketWithoutClose]
+            s.close
+          end
+        end
+      }
+      @listeners.clear
+    end
+
+    def run(sock)
+      @logger.fatal "run() must be provided by user."
+    end
+
+    private
+
+    def accept_client(svr)
+      sock = nil
+      begin
+        sock = svr.accept
+        sock.sync = true
+        Utils::set_non_blocking(sock) 
+        Utils::set_close_on_exec(sock)
+      rescue Errno::ECONNRESET, Errno::ECONNABORTED,
+             Errno::EPROTO, Errno::EINVAL => ex
+      rescue Exception => ex
+        msg = "#{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}"
+        @logger.error msg
+      end
+      return sock
+    end
+
+    def start_thread(sock, &block)
+      Thread.start{
+        begin
+          Thread.current[:WEBrickSocket] = sock
+          begin
+            addr = sock.peeraddr
+            @logger.debug "accept: #{addr[3]}:#{addr[1]}"
+          rescue SocketError
+            @logger.debug "accept: <address unknown>"
+            raise
+          end
+          call_callback(:AcceptCallback, sock)
+          block ? block.call(sock) : run(sock)
+        rescue Errno::ENOTCONN
+          @logger.debug "Errno::ENOTCONN raised"
+        rescue ServerError => ex
+          msg = "#{ex.class}: #{ex.message}\n\t#{ex.backtrace[0]}"
+          @logger.error msg
+        rescue Exception => ex
+          @logger.error ex
+        ensure
+          @tokens.push(nil)
+          Thread.current[:WEBrickSocket] = nil
+          if addr
+            @logger.debug "close: #{addr[3]}:#{addr[1]}"
+          else
+            @logger.debug "close: <address unknown>"
+          end
+          sock.close
+        end
+      }
+    end
+
+    def call_callback(callback_name, *args)
+      if cb = @config[callback_name]
+        cb.call(*args)
+      end
+    end
+  end    # end of GenericServer
+end

data/shoes/ruby/lib/webrick/ssl.rb

@@ -0,0 +1,126 @@
+#
+# ssl.rb -- SSL/TLS enhancement for GenericServer
+#
+# Copyright (c) 2003 GOTOU Yuuzou All rights reserved.
+# 
+# $Id: ssl.rb 11708 2007-02-12 23:01:19Z shyouhei $
+
+require 'webrick'
+require 'openssl'
+
+module WEBrick
+  module Config
+    svrsoft = General[:ServerSoftware]
+    osslv = ::OpenSSL::OPENSSL_VERSION.split[1]
+    SSL = {
+      :ServerSoftware       => "#{svrsoft} OpenSSL/#{osslv}",
+      :SSLEnable            => false,
+      :SSLCertificate       => nil,
+      :SSLPrivateKey        => nil,
+      :SSLClientCA          => nil,
+      :SSLExtraChainCert    => nil,
+      :SSLCACertificateFile => nil,
+      :SSLCACertificatePath => nil,
+      :SSLCertificateStore  => nil,
+      :SSLVerifyClient      => ::OpenSSL::SSL::VERIFY_NONE,
+      :SSLVerifyDepth       => nil,
+      :SSLVerifyCallback    => nil,   # custom verification
+      :SSLTimeout           => nil,
+      :SSLOptions           => nil,
+      :SSLStartImmediately  => true,
+      # Must specify if you use auto generated certificate.
+      :SSLCertName          => nil,
+      :SSLCertComment       => "Generated by Ruby/OpenSSL"
+    }
+    General.update(SSL)
+  end
+
+  module Utils
+    def create_self_signed_cert(bits, cn, comment)
+      rsa = OpenSSL::PKey::RSA.new(bits){|p, n|
+        case p
+        when 0; $stderr.putc "."  # BN_generate_prime
+        when 1; $stderr.putc "+"  # BN_generate_prime
+        when 2; $stderr.putc "*"  # searching good prime,  
+                                  # n = #of try,
+                                  # but also data from BN_generate_prime
+        when 3; $stderr.putc "\n" # found good prime, n==0 - p, n==1 - q,
+                                  # but also data from BN_generate_prime
+        else;   $stderr.putc "*"  # BN_generate_prime
+        end
+      }
+      cert = OpenSSL::X509::Certificate.new
+      cert.version = 3
+      cert.serial = 0
+      name = OpenSSL::X509::Name.new(cn)
+      cert.subject = name
+      cert.issuer = name
+      cert.not_before = Time.now
+      cert.not_after = Time.now + (365*24*60*60)
+      cert.public_key = rsa.public_key
+
+      ef = OpenSSL::X509::ExtensionFactory.new(nil,cert)
+      ef.issuer_certificate = cert
+      cert.extensions = [
+        ef.create_extension("basicConstraints","CA:FALSE"),
+        ef.create_extension("keyUsage", "keyEncipherment"),
+        ef.create_extension("subjectKeyIdentifier", "hash"),
+        ef.create_extension("extendedKeyUsage", "serverAuth"),
+        ef.create_extension("nsComment", comment),
+      ]
+      aki = ef.create_extension("authorityKeyIdentifier",
+                                "keyid:always,issuer:always")
+      cert.add_extension(aki)
+      cert.sign(rsa, OpenSSL::Digest::SHA1.new)
+
+      return [ cert, rsa ]
+    end
+    module_function :create_self_signed_cert
+  end
+
+  class GenericServer
+    def ssl_context
+      @ssl_context ||= nil
+    end
+
+    def listen(address, port)
+      listeners = Utils::create_listeners(address, port, @logger)
+      if @config[:SSLEnable]
+        unless ssl_context
+          @ssl_context = setup_ssl_context(@config)
+          @logger.info("\n" + @config[:SSLCertificate].to_text) 
+        end
+        listeners.collect!{|svr|
+          ssvr = ::OpenSSL::SSL::SSLServer.new(svr, ssl_context)
+          ssvr.start_immediately = @config[:SSLStartImmediately]
+          ssvr
+        }
+      end
+      @listeners += listeners
+    end
+
+    def setup_ssl_context(config)
+      unless config[:SSLCertificate]
+        cn = config[:SSLCertName]
+        comment = config[:SSLCertComment]
+        cert, key = Utils::create_self_signed_cert(1024, cn, comment)
+        config[:SSLCertificate] = cert
+        config[:SSLPrivateKey] = key
+      end
+      ctx = OpenSSL::SSL::SSLContext.new
+      ctx.key = config[:SSLPrivateKey]
+      ctx.cert = config[:SSLCertificate]
+      ctx.client_ca = config[:SSLClientCA]
+      ctx.extra_chain_cert = config[:SSLExtraChainCert]
+      ctx.ca_file = config[:SSLCACertificateFile]
+      ctx.ca_path = config[:SSLCACertificatePath]
+      ctx.cert_store = config[:SSLCertificateStore]
+      ctx.verify_mode = config[:SSLVerifyClient]
+      ctx.verify_depth = config[:SSLVerifyDepth]
+      ctx.verify_callback = config[:SSLVerifyCallback]
+      ctx.timeout = config[:SSLTimeout]
+      ctx.options = config[:SSLOptions]
+      ctx
+    end
+  end
+end

data/shoes/ruby/lib/webrick/utils.rb

@@ -0,0 +1,175 @@
+#
+# utils.rb -- Miscellaneous utilities
+#
+# Author: IPR -- Internet Programming with Ruby -- writers
+# Copyright (c) 2001 TAKAHASHI Masayoshi, GOTOU Yuuzou
+# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
+# reserved.
+#
+# $IPR: utils.rb,v 1.10 2003/02/16 22:22:54 gotoyuzo Exp $
+
+require 'socket'
+require 'fcntl'
+begin
+  require 'etc'
+rescue LoadError
+  nil
+end
+
+module WEBrick
+  module Utils
+    def set_non_blocking(io)
+      flag = File::NONBLOCK
+      if defined?(Fcntl::F_GETFL)
+        flag |= io.fcntl(Fcntl::F_GETFL)
+      end
+      io.fcntl(Fcntl::F_SETFL, flag)
+    end
+    module_function :set_non_blocking
+
+    def set_close_on_exec(io)
+      if defined?(Fcntl::FD_CLOEXEC)
+        io.fcntl(Fcntl::FD_CLOEXEC, 1)
+      end
+    end
+    module_function :set_close_on_exec
+
+    def su(user)
+      if defined?(Etc)
+        pw = Etc.getpwnam(user)
+        Process::initgroups(user, pw.gid)
+        Process::Sys::setgid(pw.gid)
+        Process::Sys::setuid(pw.uid)
+      else
+        warn("WEBrick::Utils::su doesn't work on this platform")
+      end
+    end
+    module_function :su
+
+    def getservername
+      host = Socket::gethostname
+      begin
+        Socket::gethostbyname(host)[0]
+      rescue
+        host
+      end
+    end
+    module_function :getservername
+
+    def create_listeners(address, port, logger=nil)
+      unless port
+        raise ArgumentError, "must specify port"
+      end
+      res = Socket::getaddrinfo(address, port,
+                                Socket::AF_UNSPEC,   # address family
+                                Socket::SOCK_STREAM, # socket type
+                                0,                   # protocol
+                                Socket::AI_PASSIVE)  # flag
+      last_error = nil
+      sockets = []
+      res.each{|ai|
+        begin
+          logger.debug("TCPServer.new(#{ai[3]}, #{port})") if logger
+          sock = TCPServer.new(ai[3], port)
+          port = sock.addr[1] if port == 0
+          Utils::set_close_on_exec(sock)
+          sockets << sock
+        rescue => ex
+          logger.warn("TCPServer Error: #{ex}") if logger
+          last_error  = ex
+        end
+      }
+      raise last_error if sockets.empty?
+      return sockets
+    end
+    module_function :create_listeners
+
+    RAND_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +
+                 "0123456789" +
+                 "abcdefghijklmnopqrstuvwxyz" 
+
+    def random_string(len)
+      rand_max = RAND_CHARS.bytesize
+      ret = "" 
+      len.times{ ret << RAND_CHARS[rand(rand_max)] }
+      ret 
+    end
+    module_function :random_string
+
+    ###########
+
+    require "thread"
+    require "timeout"
+    require "singleton"
+
+    class TimeoutHandler
+      include Singleton
+      TimeoutMutex = Mutex.new
+
+      def TimeoutHandler.register(seconds, exception)
+        TimeoutMutex.synchronize{
+          instance.register(Thread.current, Time.now + seconds, exception)
+        }
+      end
+
+      def TimeoutHandler.cancel(id)
+        TimeoutMutex.synchronize{
+          instance.cancel(Thread.current, id)
+        }
+      end
+
+      def initialize
+        @timeout_info = Hash.new
+        Thread.start{
+          while true
+            now = Time.now
+            @timeout_info.each{|thread, ary|
+              ary.dup.each{|info|
+                time, exception = *info
+                interrupt(thread, info.object_id, exception) if time < now
+              }
+            }
+            sleep 0.5
+          end
+        }
+      end
+
+      def interrupt(thread, id, exception)
+        TimeoutMutex.synchronize{
+          if cancel(thread, id) && thread.alive?
+            thread.raise(exception, "execution timeout")
+          end
+        }
+      end
+
+      def register(thread, time, exception)
+        @timeout_info[thread] ||= Array.new
+        @timeout_info[thread] << [time, exception]
+        return @timeout_info[thread].last.object_id
+      end
+
+      def cancel(thread, id)
+        if ary = @timeout_info[thread]
+          ary.delete_if{|info| info.object_id == id }
+          if ary.empty?
+            @timeout_info.delete(thread)
+          end
+          return true
+        end
+        return false
+      end
+    end
+
+    def timeout(seconds, exception=Timeout::Error)
+      return yield if seconds.nil? or seconds.zero?
+      # raise ThreadError, "timeout within critical session" if Thread.critical
+      id = TimeoutHandler.register(seconds, exception)
+      begin
+        yield(seconds)
+      ensure
+        TimeoutHandler.cancel(id)
+      end
+    end
+    module_function :timeout
+  end
+end

data/shoes/ruby/lib/webrick/version.rb

@@ -0,0 +1,13 @@
+#
+# version.rb -- version and release date
+#
+# Author: IPR -- Internet Programming with Ruby -- writers
+# Copyright (c) 2000 TAKAHASHI Masayoshi, GOTOU YUUZOU
+# Copyright (c) 2003 Internet Programming with Ruby writers. All rights
+# reserved.
+#
+# $IPR: version.rb,v 1.74 2003/07/22 19:20:43 gotoyuzo Exp $
+
+module WEBrick
+  VERSION      = "1.3.1"
+end

data/shoes/ruby/lib/webrick.rb

@@ -0,0 +1,29 @@
+#
+# WEBrick -- WEB server toolkit.
+#
+# Author: IPR -- Internet Programming with Ruby -- writers
+# Copyright (c) 2000 TAKAHASHI Masayoshi, GOTOU YUUZOU
+# Copyright (c) 2002 Internet Programming with Ruby writers. All rights
+# reserved.
+#
+# $IPR: webrick.rb,v 1.12 2002/10/01 17:16:31 gotoyuzo Exp $
+
+require 'webrick/compat.rb'
+
+require 'webrick/version.rb'
+require 'webrick/config.rb'
+require 'webrick/log.rb'
+require 'webrick/server.rb'
+require 'webrick/utils.rb'
+require 'webrick/accesslog'
+
+require 'webrick/htmlutils.rb'
+require 'webrick/httputils.rb'
+require 'webrick/cookie.rb'
+require 'webrick/httpversion.rb'
+require 'webrick/httpstatus.rb'
+require 'webrick/httprequest.rb'
+require 'webrick/httpresponse.rb'
+require 'webrick/httpserver.rb'
+require 'webrick/httpservlet.rb'
+require 'webrick/httpauth.rb'