bayserver-core 2.2.0

data/lib/baykit/bayserver/util/headers.rb

@@ -0,0 +1,194 @@
+require 'baykit/bayserver/util/http_status'
+
+module Baykit
+  module BayServer
+    module Util
+      class Headers
+        include Baykit::BayServer::Util
+
+        # 
+        # known header names
+        #
+        HEADER_SEPARATOR = ": "
+
+        CONTENT_TYPE = "content-type"
+        CONTENT_LENGTH = "content-length"
+        CONTENT_ENCODING = "content-encoding"
+        HDR_TRANSFER_ENCODING = "Transfer-Encoding"
+        CONNECTION = "Connection"
+        AUTHORIZATION = "Authorization"
+        WWW_AUTHENTICATE = "WWW-Authenticate"
+        STATUS = "Status"
+        LOCATION = "Location"
+        HOST = "Host"
+        COOKIE = "Cookie"
+        USER_AGENT = "User-Agent"
+        ACCEPT = "Accept"
+        ACCEPT_LANGUAGE = "Accept-Language"
+        ACCEPT_ENCODING = "Accept-Encoding"
+        UPGRADE_INSECURE_REQUESTS = "Upgrade-Insecure-Requests"
+        SERVER = "Server"
+        X_FORWARDED_HOST = "X-Forwarded-Host"
+        X_FORWARDED_FOR = "X-Forwarded-For"
+        X_FORWARDED_PROTO = "X-Forwarded-Proto"
+        X_FORWARDED_PORT = "X-Forwarded-Port"
+
+        CONNECTION_CLOSE = 1
+        CONNECTION_KEEP_ALIVE = 2
+        CONNECTION_UPGRADE = 3
+        CONNECTION_UNKOWN = 4
+
+        attr :status
+        attr :headers
+
+
+        def initialize
+          @headers = {}
+          clear()
+        end
+
+        def to_s()
+          return "Header(s=#{@status.to_s} h=#{@headers}"
+        end
+
+
+        def clear()
+          @headers.clear()
+          @status = HttpStatus::OK
+        end
+
+        def copy_to(dst)
+          dst.status = @status
+          @headers.keys.each do |name|
+            values = @headers[name].dup
+            dst.headers[name] = values
+          end
+        end
+
+        def status= (new_val)
+          @status = new_val.to_i
+        end
+
+        def get(name)
+          values = headers[name.downcase()]
+          if(values == nil)
+            return nil
+          else
+            return values[0]
+          end
+        end
+
+        def get_int(name)
+          val = get(name)
+          if(val == nil)
+            return -1
+          else
+            return val.to_i
+          end
+        end
+
+        def set(name, value)
+          name = name.downcase
+          values = @headers[name]
+          if(values == nil)
+            values = []
+            @headers[name] = values
+          end
+          values.clear()
+          values.append(value)
+        end
+
+
+        def set_int(name, value)
+          set(name, value.to_s)
+        end
+
+        def add(name, value)
+          name = name.downcase()
+          values = @headers[name]
+          if(values == nil)
+            values = []
+            @headers[name] = values
+          end
+          values.append(value)
+        end
+
+        def add_int(name, value)
+          add(name, value.to_s)
+        end
+
+        def names()
+          return @headers.keys()
+        end
+
+        def values(name)
+          values = @headers[name.downcase()]
+          if(values == nil)
+            return []
+          else
+            return values
+          end
+        end
+
+        def count()
+          c = 0
+          @headers.keys.each do |name|
+            @headers[name].each do |value|
+              c += 1
+            end
+          end
+          return c
+        end
+
+        def contains(name)
+          return @headers.keys.include?(name.downcase())
+        end
+
+        def remove(name)
+          @headers.delete(name.downcase())
+        end
+
+        #
+        # Utility methods
+        #
+        def content_type()
+          return get(CONTENT_TYPE)
+        end
+
+        def set_content_type(type)
+          set(CONTENT_TYPE, type)
+        end
+
+        def content_length()
+          length = get(CONTENT_LENGTH)
+          if(StringUtil.empty?(length))
+            return -1
+          else
+            return Integer(length)
+          end
+        end
+
+        def set_content_length(len)
+          set_int(CONTENT_LENGTH, len)
+        end
+
+        def get_connection
+          con = get(CONNECTION)
+          if(con != nil)
+            con = con.downcase()
+          end
+          case con
+          when "close" then
+            return CONNECTION_CLOSE
+          when "keep-alive" then
+            return CONNECTION_KEEP_ALIVE
+          when "upgrade" then
+            return CONNECTION_UPGRADE
+          else
+            return CONNECTION_UNKOWN
+          end
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/util/host_matcher.rb

@@ -0,0 +1,48 @@
+module Baykit
+  module BayServer
+    module Util
+      class HostMatcher
+        MATCH_TYPE_ALL = 1
+        MATCH_TYPE_EXACT = 2
+        MATCH_TYPE_DOMAIN = 3
+
+        attr :match_type
+        attr :host
+        attr :domain
+
+        def initialize(host)
+          if host == "*"
+            @match_type = MATCH_TYPE_ALL
+          elsif host.start_with?("*.")
+            @match_type = MATCH_TYPE_DOMAIN
+            @domain = host[2, -1]
+          else
+            @match_type = MATCH_TYPE_EXACT
+            @host = host
+          end
+        end
+
+
+        def match(remote_host)
+          if @match_type == MATCH_TYPE_ALL
+            # all match
+            return true
+          end
+
+          if remote_host == nil
+            return false
+          end
+
+          if @match_type == MATCH_TYPE_EXACT
+            # exact match
+            remote_host == @host
+          else
+            # domain match
+            remote_host.end_with?(@domain)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/baykit/bayserver/util/http_status.rb

@@ -0,0 +1,60 @@
+require 'baykit/bayserver/bcf/package'
+
+module Baykit
+  module BayServer
+    module Util
+      class HttpStatus
+        include Baykit::BayServer::Bcf
+
+        #
+        # Known status
+        # 
+        OK = 200
+        MOVED_PERMANENTLY = 301
+        MOVED_TEMPORARILY = 302
+        NOT_MODIFIED = 304
+        BAD_REQUEST = 400
+        UNAUTHORIZED = 401
+        FORBIDDEN = 403
+        NOT_FOUND = 404
+        UPGRADE_REQUIRED = 426
+        INTERNAL_SERVER_ERROR = 500
+        SERVICE_UNAVAILABLE = 503
+        GATEWAY_TIMEOUT = 504
+        HTTP_VERSION_NOT_SUPPORTED = 505
+
+        class << self
+          attr :status
+          attr :initialized
+        end
+        @status = {}
+        @initialized = false
+
+        def self.init(bcf_file)
+          if(@initialized)
+            return
+          end
+
+          p = BcfParser.new()
+          doc = p.parse(bcf_file)
+          doc.content_list.each do |kv|
+            if(kv.instance_of?(BcfKeyVal))
+              @status[kv.key.to_i] = kv.value
+            end
+          end
+          @initialized = true
+        end
+
+        def self.description(status_code)
+          desc = @status[status_code]
+          if(desc == nil)
+            BayLog.error("Status #{status_code} is invalid.")
+            return status_code.to_s()
+          else
+            return desc
+          end
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/util/http_util.rb

@@ -0,0 +1,157 @@
+require 'base64'
+require 'resolv'
+
+require 'baykit/bayserver/util/string_util'
+require 'baykit/bayserver/util/char_util'
+require 'baykit/bayserver/util/headers'
+require 'baykit/bayserver/util/http_util'
+
+module Baykit
+  module BayServer
+    module Util
+      class HttpUtil
+        include Baykit::BayServer::Util
+
+        MAX_LINE_LEN = 5000
+
+        def HttpUtil.read_line(file)
+          # Current reading line
+          buf = StringUtil.alloc(MAX_LINE_LEN)
+
+          n = 0
+          eof = false
+          while true
+            begin
+              c = file.readchar
+            rescue EOFError => e
+              eof = true
+              break
+            end
+
+            # If line is too long, return error
+            if n >= MAX_LINE_LEN
+              raise RuntimeError.new("Request line too long")
+            end
+            # If character is newline, end to read line
+            if c == CharUtil::LF
+              break
+            end
+
+            # Put the character to buffer
+            buf.concat(c)
+            n += 1
+          end
+
+          if n == 0 && eof
+            return nil
+          else
+            return buf.chomp
+          end
+        end
+
+        #
+        # Parse message headers
+        #   message-header = field-name ":" [field-value]
+        #
+        def HttpUtil.parse_message_headers(file, header)
+          while true
+            line = read_line(file)
+
+            #  if line is empty ("\r\n")
+            #  finish reading.
+            if StringUtil.empty?(line)
+              break
+            end
+
+            pos = line.index ":"
+            if pos != nil
+              key = line[0 .. pos - 1].strip
+              val = line[pos + 1 .. -1].strip
+              header.add(key, val)
+            end
+          end
+        end
+
+        #
+        # Send MIME headers This method is called from send_headers
+        #
+        def HttpUtil.send_mime_headers(headers, buf)
+
+          headers.names.each do |name|
+            headers.values(name).each do |value|
+              buf.put(name)
+              buf.put(Headers::HEADER_SEPARATOR)
+              buf.put(value)
+              send_new_line(buf)
+            end
+          end
+        end
+
+        def HttpUtil.send_new_line(buf)
+          buf.put(CharUtil::CRLF)
+        end
+
+        def HttpUtil.parse_authorization(tur)
+          auth = tur.req.headers.get(Headers::AUTHORIZATION)
+          if StringUtil.set?(auth)
+            ptn = /Basic (.*)/
+            mch = auth.match(ptn)
+            if !mch
+              BayLog.warn("Not matched with basic authentication format")
+            else
+              auth = mch[1]
+
+              auth = Base64.decode64(auth)
+              ptn = /(.*):(.*)/
+              mch = auth.match(ptn)
+              if mch
+                tur.req.remote_user = mch[1]
+                tur.req.remote_pass = mch[2]
+              end
+            end
+          end
+        end
+
+
+        def HttpUtil.parse_host_port(tur, default_port)
+          tur.req.req_host = ""
+
+          host_port = tur.req.headers.get(Headers::X_FORWARDED_HOST)
+          if StringUtil.set?(host_port)
+            tur.req.headers.remove(Headers::X_FORWARDED_HOST)
+            tur.req.headers.set(Headers::HOST, host_port)
+          end
+
+          host_port = tur.req.headers.get(Headers::HOST)
+
+          if StringUtil.set?(host_port)
+            pos = host_port.rindex(':')
+            if pos == nil
+              tur.req.req_host = host_port
+              tur.req.req_port = default_port
+            else
+              tur.req.req_host = host_port[0, pos]
+              begin
+                tur.req.req_port = host_port[pos + 1 .. -1].to_i
+              rescue => e
+                BayLog.error(e)
+              end
+            end
+          end
+        end
+
+        def HttpUtil.resolve_remote_host(adr)
+          if adr == nil
+            return nil
+          end
+          begin
+            return Resolv.getname(adr)
+          rescue => e
+            BayLog.warn_e(e, "Cannot get remote host name: %s", e)
+            return nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/util/io_util.rb

@@ -0,0 +1,32 @@
+module Baykit
+  module BayServer
+    module Util
+      class IOUtil
+        def IOUtil.read_int32(io)
+          data = "    "
+          begin
+            dt = io.read_nonblock(4, data)
+            if dt == nil
+              return nil
+            end
+          rescue EOFError => e
+            return nil
+          end
+          data = data.codepoints
+          #print("IO.read->" + data[0].to_s + "," + data[1].to_s + "," + data[2].to_s + "," + data[3].to_s)
+          return data[0] << 24 | (data[1]<< 16 & 0xFF0000) | (data[2] << 8 & 0xFF00) | (data[3] & 0xFF)
+        end
+
+        def IOUtil.write_int32(io, i)
+          data = [i >> 24, i >> 16 & 0xFF, i >> 8 & 0xFF, i & 0xFF]
+          #print("IOwrite->" + data.to_s)
+          io.write(data.pack("C*"))
+        end
+
+        def IOUtil.get_sock_recv_buf_size(skt)
+          return skt.getsockopt(Socket::SOL_SOCKET, Socket::SO_RCVBUF).int
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/util/ip_matcher.rb

@@ -0,0 +1,67 @@
+module Baykit
+  module BayServer
+    module Util
+      class IpMatcher
+        attr :match_all
+        attr :net_addr
+        attr :mask_addr
+
+        def initialize(ip_desc)
+          @match_all = (ip_desc == "*")
+
+          if !@match_all
+            parse_ip(ip_desc)
+          end
+        end
+
+        def match(ip)
+          BayLog.debug("match_ip %s net=%s mask=%s", ip, @net_addr, @mask_addr)
+          if @match_all
+            return true
+          else
+            if ip.ipv4? != @mask_addr.ipv4?
+              # IPv4 and IPv6 don't match each other
+              return false
+            end
+
+            if ip & @mask_addr != @net_addr
+              return false
+            end
+
+            return true
+          end
+        end
+
+        def get_ip_addr(ip)
+          return IPAddr.new(ip)
+        end
+
+        private
+        def parse_ip(ip_desc)
+          items = ip_desc.split("/")
+          if items.length == 0
+            raise RuntimeError.new(BayMessage.get(:CFG_INVALID_IP_DESC, ip_desc))
+          end
+
+          ip = items[0]
+          if items.length == 1
+            mask = "255.255.255.255"
+          else
+            mask = items[1]
+          end
+
+          ip_addr = get_ip_addr(ip)
+          @mask_addr = get_ip_addr(mask)
+
+          if ip_addr.ipv4? != @mask_addr.ipv4?
+            raise RuntimeError.new(BayMessage.get(:CFG_IPV4_AND_IPV6_ARE_MIXED, ip_desc))
+          end
+
+          @net_addr = ip_addr & @mask_addr
+        end
+
+
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/util/key_val.rb

@@ -0,0 +1,15 @@
+module Baykit
+  module BayServer
+    module Util
+      class KeyVal
+        attr :name
+        attr :value
+
+        def initialize(name, val)
+          @name = name
+          @value = val
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/util/key_val_list_parser.rb

@@ -0,0 +1,53 @@
+require 'baykit/bayserver/util/key_val'
+
+module Baykit
+  module BayServer
+    module Util
+      class KeyValListParser
+
+        attr :item_sep
+        attr :kv_sep
+
+        def initialize(item_sep = "&", key_val_sep = "=")
+          @item_sep = item_sep
+          @kv_sep = key_val_sep
+        end
+
+        def parse(str)
+          list = []
+          buf = ""
+          str.each do |c|
+            if(c == @item_sep)
+              list.append(divide_param(buf))
+              buf.clear()
+            else
+              buf.concat(c)
+            end
+          end
+          if(buf.length > 0)
+            list.append(divide_param(buf))
+          end
+
+          return list
+        end
+
+        private
+        def divide_param(str)
+          pos = str.index @kv_sep
+          if(pos == nil)
+            name = str
+            value = ""
+          else
+            name = str[0 .. pos]
+            value = str[pos + 1 .. -1]
+          end
+
+          name.strip!
+          KeyVal.new(name, value)
+        end
+
+      end
+    end
+  end
+end
+

data/lib/baykit/bayserver/util/locale.rb

@@ -0,0 +1,30 @@
+module Baykit
+  module BayServer
+    module Util
+      class Locale
+        attr :language
+        attr :country
+
+        def initialize(language, country)
+          @language = language
+          @country = country
+        end
+
+
+        def self.default()
+          lang = ENV['LANG']
+          if StringUtil.set?(lang)
+            begin
+              language = lang[0, 2]
+              country = lang[4, 2]
+              return Locale.new(language, country)
+            rescue => e
+              BayLog.error_e(e)
+            end
+          end
+          return Locale.new("en", "US")
+        end
+      end
+    end
+  end
+end

data/lib/baykit/bayserver/util/md5_password.rb

@@ -0,0 +1,24 @@
+require 'digest/md5'
+
+module Baykit
+  module BayServer
+    module Util
+      class MD5Password
+        def MD5Password.encode(password)
+          digest = Digest::MD5.new
+          digest.update(password)
+          return digest.digest.unpack("H*")[0]
+        end
+
+        def bytesToString(bytes)
+          ret = ""
+          bytes.each do |b|
+            b.to_s(16)
+            ret.concat(b)
+          end
+          return ret
+        end
+      end
+    end
+  end
+end