shoesgem 0.1424.0

data/shoes/ruby/lib/dl/stack.rb

@@ -0,0 +1,146 @@
+require 'dl'
+
+module DL
+  class Stack
+    def Stack.[](*types)
+      Stack.new(types)
+    end
+
+    def initialize(types)
+      parse_types(types)
+    end
+
+    def size()
+      @size
+    end
+
+    def types()
+      @types
+    end
+
+    def pack(ary)
+      case SIZEOF_VOIDP
+      when SIZEOF_LONG
+        ary.pack(@template).unpack('l!*')
+      when SIZEOF_LONG_LONG
+        ary.pack(@template).unpack('q*')
+      else
+        raise(RuntimeError, "sizeof(void*)?")
+      end
+    end
+
+    def unpack(ary)
+      case SIZEOF_VOIDP
+      when SIZEOF_LONG
+        ary.pack('l!*').unpack(@template)
+      when SIZEOF_LONG_LONG
+        ary.pack('q*').unpack(@template)
+      else
+        raise(RuntimeError, "sizeof(void*)?")
+      end
+    end
+    
+    private
+    
+    def align(addr, align)
+      d = addr % align
+      if( d == 0 )
+        addr
+      else
+        addr + (align - d)
+      end
+    end
+
+if( defined?(TYPE_LONG_LONG) )
+    ALIGN_MAP = {
+      TYPE_VOIDP => ALIGN_VOIDP,
+      TYPE_CHAR  => ALIGN_VOIDP,
+      TYPE_SHORT => ALIGN_VOIDP,
+      TYPE_INT   => ALIGN_VOIDP,
+      TYPE_LONG  => ALIGN_VOIDP,
+      TYPE_LONG_LONG => ALIGN_LONG_LONG,
+      TYPE_FLOAT => ALIGN_FLOAT,
+      TYPE_DOUBLE => ALIGN_DOUBLE,
+    }
+
+    PACK_MAP = {
+      TYPE_VOIDP => ((SIZEOF_VOIDP == SIZEOF_LONG_LONG)? "q" : "l!"),
+      TYPE_CHAR  => "c",
+      TYPE_SHORT => "s!",
+      TYPE_INT   => "i!",
+      TYPE_LONG  => "l!",
+      TYPE_LONG_LONG => "q",
+      TYPE_FLOAT => "f",
+      TYPE_DOUBLE => "d",
+    }
+
+    SIZE_MAP = {
+      TYPE_VOIDP => SIZEOF_VOIDP,
+      TYPE_CHAR  => SIZEOF_CHAR,
+      TYPE_SHORT => SIZEOF_SHORT,
+      TYPE_INT   => SIZEOF_INT,
+      TYPE_LONG  => SIZEOF_LONG,
+      TYPE_LONG_LONG => SIZEOF_LONG_LONG,
+      TYPE_FLOAT => SIZEOF_FLOAT,
+      TYPE_DOUBLE => SIZEOF_DOUBLE,
+    }
+else
+    ALIGN_MAP = {
+      TYPE_VOIDP => ALIGN_VOIDP,
+      TYPE_CHAR  => ALIGN_VOIDP,
+      TYPE_SHORT => ALIGN_VOIDP,
+      TYPE_INT   => ALIGN_VOIDP,
+      TYPE_LONG  => ALIGN_VOIDP,
+      TYPE_FLOAT => ALIGN_FLOAT,
+      TYPE_DOUBLE => ALIGN_DOUBLE,
+    }
+
+    PACK_MAP = {
+      TYPE_VOIDP => ((SIZEOF_VOIDP == SIZEOF_LONG_LONG)? "q" : "l!"),
+      TYPE_CHAR  => "c",
+      TYPE_SHORT => "s!",
+      TYPE_INT   => "i!",
+      TYPE_LONG  => "l!",
+      TYPE_FLOAT => "f",
+      TYPE_DOUBLE => "d",
+    }
+
+    SIZE_MAP = {
+      TYPE_VOIDP => SIZEOF_VOIDP,
+      TYPE_CHAR  => SIZEOF_CHAR,
+      TYPE_SHORT => SIZEOF_SHORT,
+      TYPE_INT   => SIZEOF_INT,
+      TYPE_LONG  => SIZEOF_LONG,
+      TYPE_FLOAT => SIZEOF_FLOAT,
+      TYPE_DOUBLE => SIZEOF_DOUBLE,
+    }
+end
+
+    def parse_types(types)
+      @types = types
+      @template = ""
+      addr      = 0
+      types.each{|t|
+        addr = add_padding(addr, ALIGN_MAP[t])
+        @template << PACK_MAP[t]
+        addr += SIZE_MAP[t]
+      }
+      addr = add_padding(addr, ALIGN_MAP[SIZEOF_VOIDP])
+      if( addr % SIZEOF_VOIDP == 0 )
+        @size = addr / SIZEOF_VOIDP
+      else
+        @size = (addr / SIZEOF_VOIDP) + 1
+      end
+    end
+
+    def add_padding(addr, align)
+      orig_addr = addr
+      addr = align(orig_addr, align)
+      d = addr - orig_addr
+      if( d > 0 )
+        @template << "x#{d}"
+      end
+      addr
+    end
+  end
+end

data/shoes/ruby/lib/dl/struct.rb

@@ -0,0 +1,213 @@
+require 'dl'
+require 'dl/pack.rb'
+
+module DL
+  class CStruct
+    def CStruct.entity_class()
+      CStructEntity
+    end
+  end
+
+  class CUnion
+    def CUnion.entity_class()
+      CUnionEntity
+    end
+  end
+
+  module CStructBuilder
+    def create(klass, types, members)
+      new_class = Class.new(klass){
+        define_method(:initialize){|addr|
+          @entity = klass.entity_class.new(addr, types)
+          @entity.assign_names(members)
+        }
+        define_method(:to_ptr){ @entity }
+        define_method(:to_i){ @entity.to_i }
+        members.each{|name|
+          define_method(name){ @entity[name] }
+          define_method(name + "="){|val| @entity[name] = val }
+        }
+      }
+      size = klass.entity_class.size(types)
+      new_class.module_eval(<<-EOS)
+        def new_class.size()
+          #{size}
+        end
+        def new_class.malloc()
+          addr = DL.malloc(#{size})
+          new(addr)
+        end
+      EOS
+      return new_class
+    end
+    module_function :create
+  end
+
+  class CStructEntity < CPtr
+    include PackInfo
+    include ValueUtil
+
+    def CStructEntity.malloc(types, func = nil)
+      addr = DL.malloc(CStructEntity.size(types))
+      CStructEntity.new(addr, types, func)
+    end
+
+    def CStructEntity.size(types)
+      offset = 0
+      max_align = 0
+      types.each_with_index{|t,i|
+        orig_offset = offset
+        if( t.is_a?(Array) )
+          align = PackInfo::ALIGN_MAP[t[0]]
+          offset = PackInfo.align(orig_offset, align)
+          size = offset - orig_offset
+          offset += (PackInfo::SIZE_MAP[t[0]] * t[1])
+        else
+          align = PackInfo::ALIGN_MAP[t]
+          offset = PackInfo.align(orig_offset, align)
+          size = offset - orig_offset
+          offset += PackInfo::SIZE_MAP[t]
+        end
+        if (max_align < align)
+          max_align = align
+        end
+      }
+      offset = PackInfo.align(offset, max_align)
+      offset
+    end
+
+    def initialize(addr, types, func = nil)
+      set_ctypes(types)
+      super(addr, @size, func)
+    end
+
+    def assign_names(members)
+      @members = members
+    end
+
+    def set_ctypes(types)
+      @ctypes = types
+      @offset = []
+      offset = 0
+      max_align = 0
+      types.each_with_index{|t,i|
+        orig_offset = offset
+        if( t.is_a?(Array) )
+          align = ALIGN_MAP[t[0]]
+        else
+          align = ALIGN_MAP[t]
+        end
+        offset = PackInfo.align(orig_offset, align)
+        size = offset - orig_offset
+        @offset[i] = offset
+        if( t.is_a?(Array) )
+          offset += (SIZE_MAP[t[0]] * t[1])
+        else
+          offset += SIZE_MAP[t]
+        end
+        if (max_align < align)
+          max_align = align
+        end
+      }
+      offset = PackInfo.align(offset, max_align)
+      @size = offset
+    end
+
+    def [](name)
+      idx = @members.index(name)
+      if( idx.nil? )
+        raise(ArgumentError, "no such member: #{name}")
+      end
+      ty = @ctypes[idx]
+      if( ty.is_a?(Array) )
+        r = super(@offset[idx], SIZE_MAP[ty[0]] * ty[1])
+      else
+        r = super(@offset[idx], SIZE_MAP[ty.abs])
+      end
+      packer = Packer.new([ty])
+      val = packer.unpack([r])
+      case ty
+      when Array
+        case ty[0]
+        when TYPE_VOIDP
+          val = val.collect{|v| CPtr.new(v)}
+        end
+      when TYPE_VOIDP
+        val = CPtr.new(val[0])
+      else
+        val = val[0]
+      end
+      if( ty.is_a?(Integer) && (ty < 0) )
+        return unsigned_value(val, ty)
+      elsif( ty.is_a?(Array) && (ty[0] < 0) )
+        return val.collect{|v| unsigned_value(v,ty[0])}
+      else
+        return val
+      end
+    end
+
+    def []=(name, val)
+      idx = @members.index(name)
+      if( idx.nil? )
+        raise(ArgumentError, "no such member: #{name}")
+      end
+      ty  = @ctypes[idx]
+      packer = Packer.new([ty])
+      val = wrap_arg(val, ty, [])
+      buff = packer.pack([val].flatten())
+      super(@offset[idx], buff.size, buff)
+      if( ty.is_a?(Integer) && (ty < 0) )
+        return unsigned_value(val, ty)
+      elsif( ty.is_a?(Array) && (ty[0] < 0) )
+        return val.collect{|v| unsigned_value(v,ty[0])}
+      else
+        return val
+      end
+    end
+
+    def to_s()
+      super(@size)
+    end
+  end
+
+  class CUnionEntity < CStructEntity
+    include PackInfo
+
+    def CUnionEntity.malloc(types, func=nil)
+      addr = DL.malloc(CUnionEntity.size(types))
+      CUnionEntity.new(addr, types, func)
+    end
+
+    def CUnionEntity.size(types)
+      size   = 0
+      types.each_with_index{|t,i|
+        if( t.is_a?(Array) )
+          tsize = PackInfo::SIZE_MAP[t[0]] * t[1]
+        else
+          tsize = PackInfo::SIZE_MAP[t]
+        end
+        if( tsize > size )
+          size = tsize
+        end
+      }
+    end
+
+    def set_ctypes(types)
+      @ctypes = types
+      @offset = []
+      @size   = 0
+      types.each_with_index{|t,i|
+        @offset[i] = 0
+        if( t.is_a?(Array) )
+          size = SIZE_MAP[t[0]] * t[1]
+        else
+          size = SIZE_MAP[t]
+        end
+        if( size > @size )
+          @size = size
+        end
+      }
+    end
+  end
+end
+

data/shoes/ruby/lib/dl/types.rb

@@ -0,0 +1,40 @@
+module DL
+  module Win32Types
+    def included(m)
+      m.module_eval{
+        typealias "DWORD", "unsigned long"
+        typealias "PDWORD", "unsigned long *"
+        typealias "WORD", "unsigned short"
+        typealias "PWORD", "unsigned short *"
+        typealias "BOOL", "int"
+        typealias "ATOM", "int"
+        typealias "BYTE", "unsigned char"
+        typealias "PBYTE", "unsigned char *"
+        typealias "UINT", "unsigned int"
+        typealias "ULONG", "unsigned long"
+        typealias "UCHAR", "unsigned char"
+        typealias "HANDLE", "unsigned long"
+        typealias "PHANDLE", "void*"
+        typealias "PVOID", "void*"
+        typealias "LPCSTR", "char*"
+        typealias "LPSTR", "char*"
+        typealias "HINSTANCE", "unsigned int"
+        typealias "HDC", "unsigned int"
+        typealias "HWND", "unsigned int"
+      }
+    end
+    module_function :included
+  end
+
+  module BasicTypes
+    def included(m)
+      m.module_eval{
+        typealias "uint", "unsigned int"
+        typealias "u_int", "unsigned int"
+        typealias "ulong", "unsigned long"
+        typealias "u_long", "unsigned long"
+      }
+    end
+    module_function :included
+  end
+end

data/shoes/ruby/lib/dl/value.rb

@@ -0,0 +1,112 @@
+require 'dl'
+
+module DL
+  module ValueUtil
+    def unsigned_value(val, ty)
+      case ty.abs
+      when TYPE_CHAR
+        [val].pack("c").unpack("C")[0]
+      when TYPE_SHORT
+        [val].pack("s!").unpack("S!")[0]
+      when TYPE_INT
+        [val].pack("i!").unpack("I!")[0]
+      when TYPE_LONG
+        [val].pack("l!").unpack("L!")[0]
+      when TYPE_LONG_LONG
+        [val].pack("q!").unpack("Q!")[0]
+      else
+        val
+      end
+    end
+
+    def signed_value(val, ty)
+      case ty.abs
+      when TYPE_CHAR
+        [val].pack("C").unpack("c")[0]
+      when TYPE_SHORT
+        [val].pack("S!").unpack("s!")[0]
+      when TYPE_INT
+        [val].pack("I!").unpack("i!")[0]
+      when TYPE_LONG
+        [val].pack("L!").unpack("l!")[0]
+      when TYPE_LONG_LONG
+        [val].pack("Q!").unpack("q!")[0]
+      else
+        val
+      end
+    end
+
+    def wrap_args(args, tys, funcs, &block)
+      result = []
+      tys ||= []
+      args.each_with_index{|arg, idx|
+        result.push(wrap_arg(arg, tys[idx], funcs, &block))
+      }
+      result
+    end
+
+    def wrap_arg(arg, ty, funcs, &block)
+        funcs ||= []
+        case arg
+        when nil
+          return 0
+        when CPtr
+          return arg.to_i
+        when IO
+          case ty
+          when TYPE_VOIDP
+            return CPtr[arg].to_i
+          else
+            return arg.to_i
+          end
+        when Function
+          if( block )
+            arg.bind_at_call(&block)
+            funcs.push(arg)
+          elsif !arg.bound?
+            raise(RuntimeError, "block must be given.")
+          end
+          return arg.to_i
+        when String
+          if( ty.is_a?(Array) )
+            return arg.unpack('C*')
+          else
+            case SIZEOF_VOIDP
+            when SIZEOF_LONG
+              return [arg].pack("p").unpack("l!")[0]
+            when SIZEOF_LONG_LONG
+              return [arg].pack("p").unpack("q")[0]
+            else
+              raise(RuntimeError, "sizeof(void*)?")
+            end
+          end
+        when Float, Integer
+          return arg
+        when Array
+          if( ty.is_a?(Array) ) # used only by struct
+            case ty[0]
+            when TYPE_VOIDP
+              return arg.collect{|v| Integer(v)}
+            when TYPE_CHAR
+              if( arg.is_a?(String) )
+                return val.unpack('C*')
+              end
+            end
+            return arg
+          else
+            return arg
+          end
+        else
+          if( arg.respond_to?(:to_ptr) )
+            return arg.to_ptr.to_i
+          else
+            begin
+              return Integer(arg)
+            rescue
+              raise(ArgumentError, "unknown argument type: #{arg.class}")
+            end
+          end
+        end
+    end
+  end
+end

data/shoes/ruby/lib/drb/acl.rb

@@ -0,0 +1,146 @@
+# acl-2.0 - simple Access Control List
+#
+# Copyright (c) 2000,2002,2003 Masatoshi SEKI
+#
+# acl.rb is copyrighted free software by Masatoshi SEKI.
+# You can redistribute it and/or modify it under the same terms as Ruby.
+
+require 'ipaddr'
+
+class ACL
+  VERSION=["2.0.0"]
+  class ACLEntry
+    def initialize(str)
+      if str == '*' or str == 'all'
+	@pat = [:all]
+      elsif str.include?('*')
+        @pat = [:name, dot_pat(str)]
+      else
+	begin
+	  @pat = [:ip, IPAddr.new(str)]
+	rescue ArgumentError
+	  @pat = [:name, dot_pat(str)]
+	end
+      end
+    end
+
+    private
+    def dot_pat_str(str)
+      list = str.split('.').collect { |s|
+	(s == '*') ? '.+' : s
+      }
+      list.join("\\.")
+    end
+
+    private
+    def dot_pat(str)
+      exp = "^" + dot_pat_str(str) + "$"
+      Regexp.new(exp)
+    end
+
+    public
+    def match(addr)
+      case @pat[0]
+      when :all
+	true
+      when :ip
+	begin
+	  ipaddr = IPAddr.new(addr[3])
+	  ipaddr = ipaddr.ipv4_mapped if @pat[1].ipv6? && ipaddr.ipv4?
+	rescue ArgumentError
+	  return false
+	end
+	(@pat[1].include?(ipaddr)) ? true : false
+      when :name
+	(@pat[1] =~ addr[2]) ? true : false
+      else
+	false
+      end
+    end
+  end
+
+  class ACLList
+    def initialize
+      @list = []
+    end
+
+    public
+    def match(addr)
+      @list.each do |e|
+	return true if e.match(addr)
+      end
+      false
+    end
+
+    public
+    def add(str)
+      @list.push(ACLEntry.new(str))
+    end
+  end
+
+  DENY_ALLOW = 0
+  ALLOW_DENY = 1
+
+  def initialize(list=nil, order = DENY_ALLOW)
+    @order = order
+    @deny = ACLList.new
+    @allow = ACLList.new
+    install_list(list) if list
+  end
+
+  public
+  def allow_socket?(soc)
+    allow_addr?(soc.peeraddr)
+  end
+
+  public
+  def allow_addr?(addr)
+    case @order
+    when DENY_ALLOW
+      return true if @allow.match(addr)
+      return false if @deny.match(addr)
+      return true
+    when ALLOW_DENY
+      return false if @deny.match(addr)
+      return true if @allow.match(addr)
+      return false
+    else
+      false
+    end
+  end
+
+  public
+  def install_list(list)
+    i = 0
+    while i < list.size
+      permission, domain = list.slice(i,2)
+      case permission.downcase
+      when 'allow'
+	@allow.add(domain)
+      when 'deny'
+	@deny.add(domain)
+      else
+	raise "Invalid ACL entry #{list.to_s}"
+      end
+      i += 2
+    end
+  end
+end
+
+if __FILE__ == $0
+  # example
+  list = %w(deny all
+	    allow 192.168.1.1
+            allow ::ffff:192.168.1.2
+            allow 192.168.1.3
+            )
+
+  addr = ["AF_INET", 10, "lc630", "192.168.1.3"]
+
+  acl = ACL.new
+  p acl.allow_addr?(addr)
+
+  acl = ACL.new(list, ACL::DENY_ALLOW)
+  p acl.allow_addr?(addr)
+end
+