GIF89a=( õ' 7IAXKgNgYvYx\%wh…hŽth%ˆs%—x¨}9®Œ©€&©‰%¶†(¹–.¹5·œD¹&Çš)ÇŸ5ǘ;Í£*È¡&Õ²)ׯ7×µ<Ñ»4ï°3ø‘HÖ§KͯT÷¨Yÿšqÿ»qÿÔFØ !ù ' !ÿ NETSCAPE2.0 , =( þÀ“pH,È¤rÉl:ŸÐ¨tJ­Z¯Ø¬vËíz¿à°xL.›Ïè´zÍn»ßð¸|N¯Ûïø¼~Ïïûÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§gª«ªE¯°¨¬ª±²Œ¹º¹E¾­”´ÂB¶¯ §Åȸ»ÑD¾¿Á•ÄÅ®° ÝH¾ÒLÀÆDÙ«D¶BÝïðÀ¾DÑÑÔTÌÍíH òGö¨A RÎڐ |¥ ٭&ºìE8œ¹kGÔAÞpx­a¶­ã R2XB®åE8I€Õ6Xî:vT)äžþÀq¦è³¥ì仕F~%xñ  4#ZÔ‰O|-4Bs‘X:= QÉ œš lºÒyXJŠGȦ|s hÏíK–3l7·B|¥$'7Jީܪ‰‡àá”Dæn=Pƒ ¤Òëí‰`䌨ljóá¯Éüv>á–Á¼5 ½.69ûϸd«­ºÀûnlv©‹ªîf{¬ÜãPbŸ  l5‘Ž¯pß ´ ˜3aÅùäI«O’ý·‘áÞ‡˜¾Æ‚ÙÏiÇÿ‹Àƒ #öó)pâš Þ½ ‘Ý{ó)vmÞü%D~ 6f s}ŃƒDØW Eþ`‡þ À…L8xá†ç˜{)x`X/> Ì}mø‚–RØ‘*|`D=‚Ø_ ^ð5 !_…'aä“OÚ—7âcð`D”Cx`ÝÂ¥ä‹éY¹—F¼¤¥Š?¡Õ™ n@`} lď’ÄÉ@4>ñd œ à‘vÒxNÃ×™@žd=ˆgsžG±æ ´²æud &p8Qñ)ˆ«lXD©øÜéAžHìySun jª×k*D¤LH] †¦§C™Jä–´Xb~ʪwStŽ6K,°£qÁœ:9ت:¨þªl¨@¡`‚ûÚ ».Û¬¯t‹ÆSÉ[:°=Š‹„‘Nåû”Ìî{¿ÂA ‡Rà›ÀÙ6úë°Ÿð0Ä_ ½;ÃϱîÉì^ÇÛÇ#Ëë¼ôº!±Ä˜íUîÅÇ;0L1óÁµö«p% AÀºU̬ݵ¼á%霼€‡¯Á~`ÏG¯»À× ­²± =4ªnpð3¾¤³¯­ü¾¦îuÙuµÙ®|%2ÊIÿür¦#0·ÔJ``8È@S@5ê¢ ö×Þ^`8EÜ]ý.뜃Âç 7 ú ȉÞj œ½Dç zý¸iþœÑÙûÄë!ˆÞÀl§Ïw‹*DçI€nEX¯¬¼ &A¬Go¼QföõFç°¯;é¦÷îŽêJ°îúôF5¡ÌQ|îúöXªæ»TÁÏyñêï]ê² o óÎC=öõ›ÒÓPB@ D×½œä(>èCÂxŽ`±«Ÿ–JЀ»Û á¤±p+eE0`ëŽ`A Ú/NE€Ø†À9‚@¤à H½7”à‡%B‰`Àl*ƒó‘–‡8 2ñ%¸ —€:Ù1Á‰E¸àux%nP1ð!‘ðC)¾P81lÑɸF#ˆ€{´âé°ÈB„0>±û °b¡Š´±O‚3È–Ù()yRpbµ¨E.Z‘D8ÊH@% òŒx+%Ù˜Æcü »¸˜fõ¬b·d`Fê™8èXH"ÉÈ-±|1Ô6iI, 2““¬$+](A*jÐ QTÂo‰.ÛU슬Œã„Ž`¯SN¡–¶Äåyše¯ª’­¬‚´b¦Éož œ)åyâ@Ì®3 ÎtT̉°&Ø+žLÀf"Ø-|žçÔ>‡Ðv¦Ðžì\‚ Q1)Ž@Žh#aP72”ˆ™¨$‚ !ù " , =( …7IAXG]KgNgYvYxR"k\%w]'}hŽth%ˆg+ˆs%—r.—m3šx3˜x¨}9®€&©€+¨‡7§‰%¶†(¹–.¹œD¹&ǘ;Í•&ײ)×»4ïÌ6ò§KÍ þ@‘pH,È¤rÉl:ŸÐ¨tJ­Z¯Ø¬vËíz¿à°xL.›Ïè´zÍn»ßð¸|N¯Ûïø¼~Ïïûÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§g «¬ E ±± ¨­¶°ººE Á´”·®C¬²§Ç¶Œ»ÓDÃÕƷ¯Ê±H½ºM×ÁGÚ¬D¶BËÁ½î½DÓôTÏÛßîG»ôõC×CÌ l&âž:'òtU³6ɹ#·Ø)€'Ü.6±&ëÍÈ» K(8p0N?!æ2"ÛˆNIJX>R¼ÐO‚M '¡¨2¸*Ÿþ>#n↠å@‚<[:¡Iïf’ ¤TÚ˘CdbÜÙ“[«ŽEú5MBo¤×@€`@„€Êt W-3 ¶Ÿ¡BíêäjIÝ…Eò9[T…$íêﯧ„…•s»Óȳ¹€ÅÚdc®UUρ#±Ùïldj?´í¼²`\ŽÁðÞu|3'ÖŒ]ë6 ¶S#²‡˜FKLÈ *N E´‘áäŠ$˜›eÄYD„ºq«.è촁ƒs \-ÔjA 9²õ÷å- üúM[Âx(ís÷ì®x€|í¡Ù’p¦‚ ŽkÛTÇDpE@WÜ ²Ç]kŠ1¨ þ€·Yb ÓÁ‰l°*n0 ç™—žzBdОu¾7ĉBl€â‰-ºx~|UåU‰  h*Hœ|e"#"?vpÄiŠe6^ˆ„+qâŠm8 #VÇá ‘å–ÄV„œ|Šè•m"сœn|@›U¶ÆΞ—Špb¥G¨ED”€±Úê2FÌIç? >Éxå Œ± ¡¤„%‘žjŸ‘ꄯ<Ìaà9ijÐ2˜D¦È&›†Z`‚å]wþ¼Â:ç6àB¤7eFJ|õÒ§Õ,¨äàFÇ®cS·Ê¶+B°,‘Þ˜ºNûãØ>PADÌHD¹æž«ÄÀnÌ¥}­#Ë’ë QÀÉSÌÂÇ2ÌXÀ{æk²lQÁ2«ÊðÀ¯w|2Í h‹ÄÂG€,m¾¶ë3ÐÙ6-´ÅE¬L°ÆIij*K½ÀÇqï`DwVÍQXœÚÔpeœ±¬Ñ q˜§Tœ½µƒ°Œìu Â<¶aØ*At¯lmEØ ü ôÛN[P1ÔÛ¦­±$ÜÆ@`ùåDpy¶yXvCAyåB`ŽD¶ 0QwG#¯ æš[^Äþ $ÀÓÝǦ{„L™[±úKÄgÌ;ï£S~¹ìGX.ôgoT.»åˆ°ùŸûù¡?1zö¦Ÿž:ÅgÁ|ìL¹ „®£œŠ‚à0œ]PÁ^p F<"•ç?!,ñ‡N4—…PÄ Á„ö¨Û:Tè@hÀ‹%táÿ:ø-žI<`þ‹p I….)^ 40D#p@ƒj4–؀:²‰1Øâr˜¼F2oW¼#Z†;$Q q” ‘ ÂK¦ñNl#29 !’F@¥Bh·ᏀL!—XFóLH‘Kh¤.«hE&JòG¨¥<™WN!€ÑÙÚˆY„@†>Œž19J" 2,/ &.GXB%ÌRÈ9B6¹W]’î×ÔW¥’IÎ$ ñ‹ÓŒE8YÆ ¼³™ñA5“à®Q.aŸB€&Ø©³ JÁ—! ¦t)K%tœ-¦JF bòNMxLôþ)ÐR¸Ð™‘ èÝ6‘O!THÌ„HÛ ‰ !ù ) , =( …AXKgNgYvYxR"k\%wh…hŽh%ˆg+ˆs%—r.—x3˜x¨}9®€&©€+¨Œ,©‡7§‰%¶†(¹–.¹5·&Çš)ǘ;Í•&×£*Ȳ)ׯ7×»4ï°3øÌ6ò‘HÖ§KÍ»Hó¯T÷¨Yÿ»qÿÇhÿ þÀ”pH,È¤rÉl:ŸÐ¨tJ­Z¯Ø¬vËíz¿à°xL.›Ïè´zÍn»ßð¸|N¯Ûïø¼~Ïïûÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§g ª« E$±²¨ª­ · °²½$E$ÂÕ««D· Í ¿¦Ç¶¸ÌŒ¾³CÃÅÆ E ééH½MÛÂGâªD­ çBêêϾD²ÒaÀà€Š1r­ðÓ¤ ÔožzU!L˜C'¾yW½UGtäÇïÙllê0×àÂuGþ)AÀs[þ·xì ÁxO%ƒûX2ó—  P£n›R/¡ÑšHše+êDm?# —‘Ç£6¡8íJ¡ŸâDiäªM¥Ö„ôj“¬¹£5oQ7°- <‡ *´lãÓŒ2r/a!l)dÈ A™ÈE¢ôÔ͆…ð ;Ö˜c ¡%ß‚’Ùˆâ¸b½—pe~C"BíëÚHïeF2§æŠ8qb t_`urŠeü wÅu3êæPv§h•"ß`íÍxçLĹÜÖ3á  ~Öº“®›¸ÏMDfJÙ °„ÛµáWõ%§œ‚à©–‚X Ó؁)@®Ñ›Eþ´wëuÅSxb8y\mÖzœ¥§ZbºE—ÂLªÌw!y(>¡™wú=Ç|ÅÝs¢d €CÁW)HÜcC$€L Ä7„r.á\{)@ð` @ äXÈ$PD” `šaG:§æˆOˆ72EÐamn]ù"ŒcÊxÑŒ° &dR8`g«iÙŸLR!¦P …d’ä¡“¦ðÎTƒ¦ià|À _ ¥ Qi#¦Šg›Æ ›noMµ ›V ã£)p ç£ÎW…š=Âeªk§†j„ ´®1ß²sÉxéW«jšl|0¯B0Û, \jÛ´›6±¬¶C ÛíWþï|ëÙ‹¸ñzĸV {ì;Ýñn¼òVˆm³I¼³.Ðã¤PN¥ ²µ¼„µCã+¹ÍByî£Ñ¾HŸ›ëê 7ìYÆFTk¨SaoaY$Dµœìï¿Ã29RÈkt Çïfñ ÇÒ:ÀÐSp¹3ÇI¨â¥DZÄ ü9Ïýögñ½­uÔ*3)O‘˜Ö[_hv ,àî×Et Ÿé¶BH€ Õ[ü±64M@ÔSÌM7dÐl5-ÄÙU܍´©zߌ3Ô€3ž„ „ ¶ÛPô½5×g› êÚ˜kN„Ý…0Îj4€Ìë°“#{þÕ3S2çKÜ'ợlø¼Ú2K{° {Û¶?žm𸧠ËI¼nEò='êüóºè^üæÃ_Û=°óž‚ì#Oý¿Í'¡½áo..ÏYìnüñCœO±Áa¿¢Kô½o,üÄËbö²çºíï{ËC Ú— "”Ï{ËK ÍÒw„õ±Oz dÕ¨à:$ ƒô—«v»] A#ð «€¿šéz)Rx׿ˆ¥‚d``èw-îyÏf×K!ð€þ­Ð|ìPľ„=Ì`ý(f” 'Pa ¥ÐBJa%Ðâf§„%Š¡}FàáÝ×6>ÉäŠG"éŽè=ø!oŠ°^FP¼Ø©Q„ÀCÙÁ`(Ž\ÄÝ® ©Â$<n@dÄ E#ììUÒI! ‚#lù‹`k¦ÐÇ'Rró’ZýNBÈMF Í[¤+‹ðɈ-áwj¨¥þ8¾rá ,VÂh„"|½œ=×G_¦Ñ™EØ 0i*%̲˜Æda0mV‚k¾)›;„&6 p>ÓjK “¦Ç# âDÂ:ûc?:R Ó¬fÞéI-Ì“•Ã<ä=™Ï7˜3œ¨˜c2ŒW ,ˆ”8(T™P‰F¡Jhç"‚ ; 403WebShell
403Webshell
Server IP : 104.21.83.152  /  Your IP : 216.73.216.165
Web Server : LiteSpeed
System : Linux premium229.web-hosting.com 4.18.0-553.45.1.lve.el8.x86_64 #1 SMP Wed Mar 26 12:08:09 UTC 2025 x86_64
User : akhalid ( 749)
PHP Version : 8.3.22
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : ON  |  Sudo : OFF  |  Pkexec : OFF
Directory :  /opt/alt/ruby34/share/ruby/fiddle/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ Back ]     

Current File : /opt/alt/ruby34/share/ruby/fiddle/ffi_backend.rb
# This is based on JRuby's FFI-based fiddle implementation.

require 'ffi'

module Fiddle
  def self.malloc(size)
    Fiddle::Pointer.malloc(size)
  end

  def self.free(ptr)
    Fiddle::Pointer::LibC::FREE.call(ptr)
    nil
  end

  def self.dlwrap(val)
    Pointer.to_ptr(val)
  end

  module Types
    VOID         = 0
    VOIDP        = 1
    CHAR         = 2
    UCHAR        = -CHAR
    SHORT        = 3
    USHORT       = -SHORT
    INT          = 4
    UINT         = -INT
    LONG         = 5
    ULONG        = -LONG
    LONG_LONG    = 6
    ULONG_LONG   = -LONG_LONG
    FLOAT        = 7
    DOUBLE       = 8
    VARIADIC     = 9
    CONST_STRING = 10
    BOOL         = 11
    INT8_T       = CHAR
    UINT8_T      = UCHAR
    if FFI::Type::Builtin::SHORT.size == 2
      INT16_T    = SHORT
      UINT16_T   = USHORT
    elsif FFI::Type::Builtin::INT.size == 2
      INT16_T    = INT
      UINT16_T   = UINT
    end
    if FFI::Type::Builtin::SHORT.size == 4
      INT32_T    = SHORT
      UINT32_T   = USHORT
    elsif FFI::Type::Builtin::INT.size == 4
      INT32_T    = INT
      UINT32_T   = UINT
    elsif FFI::Type::Builtin::LONG.size == 4
      INT32_T    = LONG
      UINT32_T   = ULONG
    end
    if FFI::Type::Builtin::INT.size == 8
      INT64_T    = INT
      UINT64_T   = UINT
    elsif FFI::Type::Builtin::LONG.size == 8
      INT64_T    = LONG
      UINT64_T   = ULONG
    else
      INT64_T    = LONG_LONG
      UINT64_T   = ULONG_LONG
    end

    # FIXME: platform specific values
    SSIZE_T      = INT64_T
    SIZE_T       = -SSIZE_T
    PTRDIFF_T    = SSIZE_T
    INTPTR_T     = INT64_T
    UINTPTR_T    = -INTPTR_T
  end

  WINDOWS = FFI::Platform.windows?

  module FFIBackend
    FFITypes = {
        'c' => FFI::Type::INT8,
        'h' => FFI::Type::INT16,
        'i' => FFI::Type::INT32,
        'l' => FFI::Type::LONG,
        'f' => FFI::Type::FLOAT32,
        'd' => FFI::Type::FLOAT64,
        'p' => FFI::Type::POINTER,
        's' => FFI::Type::STRING,

        Types::VOID => FFI::Type::Builtin::VOID,
        Types::VOIDP => FFI::Type::Builtin::POINTER,
        Types::CHAR => FFI::Type::Builtin::CHAR,
        Types::UCHAR => FFI::Type::Builtin::UCHAR,
        Types::SHORT => FFI::Type::Builtin::SHORT,
        Types::USHORT => FFI::Type::Builtin::USHORT,
        Types::INT => FFI::Type::Builtin::INT,
        Types::UINT => FFI::Type::Builtin::UINT,
        Types::LONG => FFI::Type::Builtin::LONG,
        Types::ULONG => FFI::Type::Builtin::ULONG,
        Types::LONG_LONG => FFI::Type::Builtin::LONG_LONG,
        Types::ULONG_LONG => FFI::Type::Builtin::ULONG_LONG,
        Types::FLOAT => FFI::Type::Builtin::FLOAT,
        Types::DOUBLE => FFI::Type::Builtin::DOUBLE,
        Types::BOOL => FFI::Type::Builtin::BOOL,
        Types::CONST_STRING => FFI::Type::Builtin::POINTER,
        Types::VARIADIC => FFI::Type::Builtin::VARARGS,
    }

    def self.to_ffi_type(fiddle_type)
      if fiddle_type.is_a?(Symbol)
        fiddle_type = Types.const_get(fiddle_type.to_s.upcase)
      end
      if !fiddle_type.is_a?(Integer) && fiddle_type.respond_to?(:to_int)
        fiddle_type = fiddle_type.to_int
      end
      ffi_type = FFITypes[fiddle_type]
      ffi_type = FFITypes[-fiddle_type] if ffi_type.nil? && fiddle_type.is_a?(Integer) && fiddle_type < 0
      raise TypeError.new("cannot convert #{fiddle_type} to ffi") unless ffi_type
      ffi_type
    end
  end

  class Function
    DEFAULT = "default"
    STDCALL = "stdcall"

    def initialize(ptr, args, return_type, abi = DEFAULT, kwargs = nil)
      if kwargs.nil?
        if abi.kind_of? Hash
          kwargs = abi
          abi = DEFAULT
        end
      end
      @name = kwargs[:name] if kwargs.kind_of? Hash
      @ptr, @args, @return_type, @abi = ptr, args, return_type, abi
      raise TypeError.new "invalid argument types" unless args.is_a?(Array)

      ffi_return_type = Fiddle::FFIBackend.to_ffi_type(@return_type)
      ffi_args = @args.map { |t| Fiddle::FFIBackend.to_ffi_type(t) }
      pointer = FFI::Pointer.new(ptr.to_i)
      options = {convention: @abi}
      if ffi_args.last == FFI::Type::Builtin::VARARGS
        @function = FFI::VariadicInvoker.new(
          pointer,
          ffi_args,
          ffi_return_type,
          options
        )
      else
        @function = FFI::Function.new(ffi_return_type, ffi_args, pointer, options)
      end
    end

    def call(*args, &block)
      if @function.is_a?(FFI::VariadicInvoker)
        n_fixed_args = @args.size - 1
        n_fixed_args.step(args.size - 1, 2) do |i|
          if args[i] == :const_string || args[i] == Types::CONST_STRING
            args[i + 1] = String.try_convert(args[i + 1]) || args[i + 1]
          end
          args[i] = Fiddle::FFIBackend.to_ffi_type(args[i])
        end
      else
        @args.each_with_index do |arg_type, i|
          next unless arg_type == Types::VOIDP

          src = args[i]
          next if src.nil?
          next if src.is_a?(String)
          next if src.is_a?(FFI::AbstractMemory)
          next if src.is_a?(FFI::Struct)

          args[i] = Pointer[src]
        end
      end
      result = @function.call(*args, &block)
      result = Pointer.new(result) if result.is_a?(FFI::Pointer)
      result
    end
  end

  class Closure
    def initialize(ret, args, abi = Function::DEFAULT)
      raise TypeError.new "invalid argument types" unless args.is_a?(Array)

      @ctype, @args = ret, args
      ffi_args = @args.map { |t| Fiddle::FFIBackend.to_ffi_type(t) }
      if ffi_args.size == 1 && ffi_args[0] == FFI::Type::Builtin::VOID
        ffi_args = []
      end
      return_type = Fiddle::FFIBackend.to_ffi_type(@ctype)
      raise "#{self.class} must implement #call" unless respond_to?(:call)
      callable = method(:call)
      @function = FFI::Function.new(return_type, ffi_args, callable, convention: abi)
      @freed = false
    end

    def to_ptr
      @function
    end

    def to_i
      @function.to_i
    end

    def free
      return if @freed
      @function.free
      @freed = true
    end

    def freed?
      @freed
    end
  end

  class Error < StandardError; end
  class DLError < Error; end
  class ClearedReferenceError < Error; end

  class Pointer
    attr_reader :ffi_ptr
    extend FFI::DataConverter
    native_type FFI::Type::Builtin::POINTER

    def self.to_native(value, ctx)
      if value.is_a?(Pointer)
        value.ffi_ptr

      elsif value.is_a?(Integer)
        FFI::Pointer.new(value)

      elsif value.is_a?(String)
        value
      end
    end

    def self.from_native(value, ctx)
      self.new(value)
    end

    def self.to_ptr(value)
      if value.is_a?(String)
        cptr = Pointer.malloc(value.bytesize)
        cptr.ffi_ptr.put_string(0, value)
        cptr

      elsif value.is_a?(Array)
        raise NotImplementedError, "array ptr"

      elsif value.respond_to?(:to_ptr)
        ptr = value.to_ptr
        case ptr
        when Pointer
          ptr
        when FFI::Pointer
          Pointer.new(ptr)
        else
          raise DLError.new("to_ptr should return a Fiddle::Pointer object, was #{ptr.class}")
        end

      else
        Pointer.new(value)
      end
    end

    def self.write(addr, bytes)
      FFI::Pointer.new(addr).write_bytes(bytes)
    end

    def self.read(addr, len)
      FFI::Pointer.new(addr).read_bytes(len)
    end

    class << self
      alias [] to_ptr
    end

    def []=(*args, value)
      if args.size == 2
        if value.is_a?(Integer)
          value = self.class.new(value)
        end
        if value.is_a?(Fiddle::Pointer)
          value = value.to_str(args[1])
        end

        @ffi_ptr.put_bytes(args[0], value, 0, args[1])
      elsif args.size == 1
        if value.is_a?(Fiddle::Pointer)
          value = value.to_str(args[0] + 1)
        else
          value = value.chr
        end

        @ffi_ptr.put_bytes(args[0], value, 0, 1)
      end
    rescue FFI::NullPointerError
      raise DLError.new("NULL pointer access")
    end

    def initialize(addr, size = nil, free = nil)
      ptr = if addr.is_a?(FFI::Pointer)
              addr

            elsif addr.is_a?(Integer)
              FFI::Pointer.new(addr)

            elsif addr.respond_to?(:to_ptr)
              fiddle_ptr = addr.to_ptr
              if fiddle_ptr.is_a?(Pointer)
                fiddle_ptr.ffi_ptr
              elsif fiddle_ptr.is_a?(FFI::AutoPointer)
                addr.ffi_ptr
              elsif fiddle_ptr.is_a?(FFI::Pointer)
                fiddle_ptr
              else
                raise DLError.new("to_ptr should return a Fiddle::Pointer object, was #{fiddle_ptr.class}")
              end
            elsif addr.is_a?(IO)
              raise NotImplementedError, "IO ptr isn't supported"
            else
              FFI::Pointer.new(Integer(addr))
            end

      @size = size ? size : ptr.size
      @free = free
      @ffi_ptr = ptr
      @freed = false
    end

    module LibC
      extend FFI::Library
      ffi_lib FFI::Library::LIBC
      MALLOC = attach_function :malloc, [ :size_t ], :pointer
      REALLOC = attach_function :realloc, [ :pointer, :size_t ], :pointer
      FREE = attach_function :free, [ :pointer ], :void
    end

    def self.malloc(size, free = nil)
      if block_given? and free.nil?
        message = "a free function must be supplied to #{self}.malloc " +
                  "when it is called with a block"
        raise ArgumentError, message
      end

      pointer = new(LibC.malloc(size), size, free)
      if block_given?
        begin
          yield(pointer)
        ensure
          pointer.call_free
        end
      else
        pointer
      end
    end

    def null?
      @ffi_ptr.null?
    end

    def to_ptr
      @ffi_ptr
    end

    def size
      defined?(@layout) ? @layout.size : @size
    end

    def free
      @free
    end

    def free=(free)
      @free = free
    end

    def call_free
      return if @free.nil?
      return if @freed
      if @free == RUBY_FREE
        LibC::FREE.call(@ffi_ptr)
      else
        @free.call(@ffi_ptr)
      end
      @freed = true
    end

    def freed?
      @freed
    end

    def size=(size)
      @size = size
    end

    def [](index, length = nil)
      if length
        ffi_ptr.get_bytes(index, length)
      else
        ffi_ptr.get_char(index)
      end
    rescue FFI::NullPointerError
      raise DLError.new("NULL pointer dereference")
    end

    def to_i
      ffi_ptr.to_i
    end
    alias to_int to_i

    # without \0
    def to_s(len = nil)
      if len
        ffi_ptr.get_string(0, len)
      else
        ffi_ptr.get_string(0)
      end
    rescue FFI::NullPointerError
      raise DLError.new("NULL pointer access")
    end

    def to_str(len = nil)
      if len
        ffi_ptr.read_string(len)
      else
        ffi_ptr.read_string(@size)
      end
    rescue FFI::NullPointerError
      raise DLError.new("NULL pointer access")
    end

    def to_value
      raise NotImplementedError, "to_value isn't supported"
    end

    def inspect
      "#<#{self.class.name} ptr=#{to_i.to_s(16)} size=#{@size} free=#{@free.inspect}>"
    end

    def +(delta)
      self.class.new(to_i + delta, @size - delta)
    end

    def -(delta)
      self.class.new(to_i - delta, @size + delta)
    end

    def <=>(other)
      return unless other.is_a?(Pointer)
      diff = self.to_i - other.to_i
      return 0 if diff == 0
      diff > 0 ? 1 : -1
    end

    def eql?(other)
      return unless other.is_a?(Pointer)
      self.to_i == other.to_i
    end

    def ==(other)
      eql?(other)
    end

    def ptr
      Pointer.new(ffi_ptr.get_pointer(0))
    end

    def +@
      ptr
    end

    def -@
      ref
    end

    def ref
      cptr = Pointer.malloc(FFI::Type::POINTER.size, RUBY_FREE)
      cptr.ffi_ptr.put_pointer(0, ffi_ptr)
      cptr
    end
  end

  class Handle
    RTLD_GLOBAL = FFI::DynamicLibrary::RTLD_GLOBAL
    RTLD_LAZY = FFI::DynamicLibrary::RTLD_LAZY
    RTLD_NOW = FFI::DynamicLibrary::RTLD_NOW

    def initialize(libname = nil, flags = RTLD_LAZY | RTLD_GLOBAL)
      begin
        @lib = FFI::DynamicLibrary.open(libname, flags)
      rescue LoadError, RuntimeError # LoadError for JRuby, RuntimeError for TruffleRuby
        raise DLError, "Could not open #{libname}"
      end

      @open = true

      begin
        yield(self)
      ensure
        self.close
      end if block_given?
    end

    def close
      raise DLError.new("closed handle") unless @open
      @open = false
      0
    end

    def self.sym(func)
      DEFAULT.sym(func)
    end

    def sym(func)
      raise TypeError.new("invalid function name") unless func.is_a?(String)
      raise DLError.new("closed handle") unless @open
      address = @lib.find_function(func)
      raise DLError.new("unknown symbol #{func}") if address.nil? || address.null?
      address.to_i
    end

    def self.sym_defined?(func)
      DEFAULT.sym_defined?(func)
    end

    def sym_defined?(func)
      raise TypeError.new("invalid function name") unless func.is_a?(String)
      raise DLError.new("closed handle") unless @open
      address = @lib.find_function(func)
      !address.nil? && !address.null?
    end

    def self.[](func)
      self.sym(func)
    end

    def [](func)
      sym(func)
    end

    def enable_close
      @enable_close = true
    end

    def close_enabled?
      @enable_close
    end

    def disable_close
      @enable_close = false
    end

    DEFAULT = new
  end

  class Pinned
    def initialize(object)
      @object = object
    end

    def ref
      if @object.nil?
        raise ClearedReferenceError, "`ref` called on a cleared object"
      end
      @object
    end

    def clear
      @object = nil
    end

    def cleared?
      @object.nil?
    end
  end

  RUBY_FREE = Fiddle::Pointer::LibC::FREE.address
  NULL = Fiddle::Pointer.new(0)

  ALIGN_VOIDP       = Fiddle::FFIBackend::FFITypes[Types::VOIDP].alignment
  ALIGN_CHAR        = Fiddle::FFIBackend::FFITypes[Types::CHAR].alignment
  ALIGN_SHORT       = Fiddle::FFIBackend::FFITypes[Types::SHORT].alignment
  ALIGN_INT         = Fiddle::FFIBackend::FFITypes[Types::INT].alignment
  ALIGN_LONG        = Fiddle::FFIBackend::FFITypes[Types::LONG].alignment
  ALIGN_LONG_LONG   = Fiddle::FFIBackend::FFITypes[Types::LONG_LONG].alignment
  ALIGN_INT8_T      = Fiddle::FFIBackend::FFITypes[Types::INT8_T].alignment
  ALIGN_INT16_T     = Fiddle::FFIBackend::FFITypes[Types::INT16_T].alignment
  ALIGN_INT32_T     = Fiddle::FFIBackend::FFITypes[Types::INT32_T].alignment
  ALIGN_INT64_T     = Fiddle::FFIBackend::FFITypes[Types::INT64_T].alignment
  ALIGN_FLOAT       = Fiddle::FFIBackend::FFITypes[Types::FLOAT].alignment
  ALIGN_DOUBLE      = Fiddle::FFIBackend::FFITypes[Types::DOUBLE].alignment
  ALIGN_BOOL        = Fiddle::FFIBackend::FFITypes[Types::BOOL].alignment
  ALIGN_SIZE_T      = Fiddle::FFIBackend::FFITypes[Types::SIZE_T].alignment
  ALIGN_SSIZE_T     = ALIGN_SIZE_T
  ALIGN_PTRDIFF_T   = Fiddle::FFIBackend::FFITypes[Types::PTRDIFF_T].alignment
  ALIGN_INTPTR_T    = Fiddle::FFIBackend::FFITypes[Types::INTPTR_T].alignment
  ALIGN_UINTPTR_T   = Fiddle::FFIBackend::FFITypes[Types::UINTPTR_T].alignment

  SIZEOF_VOIDP       = Fiddle::FFIBackend::FFITypes[Types::VOIDP].size
  SIZEOF_CHAR        = Fiddle::FFIBackend::FFITypes[Types::CHAR].size
  SIZEOF_UCHAR       = Fiddle::FFIBackend::FFITypes[Types::UCHAR].size
  SIZEOF_SHORT       = Fiddle::FFIBackend::FFITypes[Types::SHORT].size
  SIZEOF_USHORT      = Fiddle::FFIBackend::FFITypes[Types::USHORT].size
  SIZEOF_INT         = Fiddle::FFIBackend::FFITypes[Types::INT].size
  SIZEOF_UINT        = Fiddle::FFIBackend::FFITypes[Types::UINT].size
  SIZEOF_LONG        = Fiddle::FFIBackend::FFITypes[Types::LONG].size
  SIZEOF_ULONG       = Fiddle::FFIBackend::FFITypes[Types::ULONG].size
  SIZEOF_LONG_LONG   = Fiddle::FFIBackend::FFITypes[Types::LONG_LONG].size
  SIZEOF_ULONG_LONG  = Fiddle::FFIBackend::FFITypes[Types::ULONG_LONG].size
  SIZEOF_INT8_T      = Fiddle::FFIBackend::FFITypes[Types::INT8_T].size
  SIZEOF_UINT8_T     = Fiddle::FFIBackend::FFITypes[Types::UINT8_T].size
  SIZEOF_INT16_T     = Fiddle::FFIBackend::FFITypes[Types::INT16_T].size
  SIZEOF_UINT16_T    = Fiddle::FFIBackend::FFITypes[Types::UINT16_T].size
  SIZEOF_INT32_T     = Fiddle::FFIBackend::FFITypes[Types::INT32_T].size
  SIZEOF_UINT32_T    = Fiddle::FFIBackend::FFITypes[Types::UINT32_T].size
  SIZEOF_INT64_T     = Fiddle::FFIBackend::FFITypes[Types::INT64_T].size
  SIZEOF_UINT64_T    = Fiddle::FFIBackend::FFITypes[Types::UINT64_T].size
  SIZEOF_FLOAT       = Fiddle::FFIBackend::FFITypes[Types::FLOAT].size
  SIZEOF_DOUBLE      = Fiddle::FFIBackend::FFITypes[Types::DOUBLE].size
  SIZEOF_BOOL        = Fiddle::FFIBackend::FFITypes[Types::BOOL].size
  SIZEOF_SIZE_T      = Fiddle::FFIBackend::FFITypes[Types::SIZE_T].size
  SIZEOF_SSIZE_T     = SIZEOF_SIZE_T
  SIZEOF_PTRDIFF_T   = Fiddle::FFIBackend::FFITypes[Types::PTRDIFF_T].size
  SIZEOF_INTPTR_T    = Fiddle::FFIBackend::FFITypes[Types::INTPTR_T].size
  SIZEOF_UINTPTR_T   = Fiddle::FFIBackend::FFITypes[Types::UINTPTR_T].size
  SIZEOF_CONST_STRING = Fiddle::FFIBackend::FFITypes[Types::VOIDP].size
end

Youez - 2016 - github.com/yon3zu
LinuXploit