nwrfc 0.0.0

data/lib/nwrfc.rb

@@ -0,0 +1,409 @@
+# Author:: Martin Ceronio martin.ceronio@infosize.co.za
+# Copyright:: Copyright (c) 2012 Martin Ceronio
+# License:: MIT and/or Creative Commons Attribution-ShareAlike
+# SAP, Netweaver, RFC and other names referred to in this code
+# are, or may be registered trademarks and the property of SAP, AG
+# No ownership over any of these is asserted by Martin Ceronio
+
+require File.dirname(__FILE__)+'/nwrfc/nwrfclib'
+
+require 'date'
+require 'time'
+
+# This library provides a way to call the functions of the SAP Netweaver RFC
+# SDK, i.e. opening a connection to an ABAP system, calling functions etc., as
+# well as running an RFC service
+#---
+# *TODO*: Create an error class that wraps the SAP error struct, so it can
+# be raised and the caller can get all the information from there
+#+++
+
+module NWRFC
+
+  NW_TIME_FORMAT = "%H%M%S"
+  NW_DATE_FORMAT = "%Y%m%d"
+
+  def inspect
+    self.to_s
+  end
+
+  def NWRFC.get_version
+    # See custom method FFI::Pointer#read_string_dn in nwrfclib.rb
+    # http://stackoverflow.com/questions/9293307/ruby-ffi-ruby-1-8-reading-utf-16le-encoded-strings
+    major = FFI::MemoryPointer.new(:uint)
+    minor = FFI::MemoryPointer.new(:uint)
+    patch = FFI::MemoryPointer.new(:uint)
+    version = NWRFCLib.get_version(major, minor, patch)
+    [version.read_string_dn.uC, major.read_uint, minor.read_uint, patch.read_uint]
+  end
+
+  def NWRFC.check_error(error_handle)
+    raise "Error code #{error_handle[:code]} group #{error_handle[:group]} message #{error_handle[:message].get_str}" \
+      if error_handle[:code] > 0
+  end
+
+  # Represents a connection to a SAP system that can be used to invoke
+  # remote-enabled functions
+  class Connection
+    attr_reader :handle
+
+    # Opens a connection to the SAP system with the given connection parameters
+    # (described in the NW RFC SDK document), passed in the form of a Hash, e.g.
+    #   Connection.new { 'ashost' :=> 'ajax.domain.com', ... }
+    def initialize(conn_params)
+      conn_params.untaint #For params loaded from file, e.g.
+      raise "Connection parameters must be a Hash" unless conn_params.instance_of? Hash
+      #NWRFCLib.init
+      @cparams = NWRFCLib.make_conn_params(conn_params)
+      raise "Could not create valid pointer from parameters" unless @cparams.instance_of? FFI::MemoryPointer
+      #@errp = FFI::MemoryPointer.new(NWRFCLib::RFCError)
+      @error =  NWRFCLib::RFCError.new #@errp
+      @handle = NWRFCLib.open_connection(@cparams, conn_params.length, @error.to_ptr)
+      NWRFC.check_error(@error)
+      self
+    end
+
+    # Call the NW RFC SDK's RfcCloseConnection() function with the current
+    # connection; this (should - *TODO* - check) invalidate the connection handle
+    # and cause an error on any subsequent use of this connection
+    def disconnect
+      NWRFCLib.close_connection(@handle, @error.to_ptr)
+      NWRFC.check_error(@error)
+    end
+    
+    def get_function(function_name)
+      Function.new(self, function_name)
+    end
+
+    # Return details about the current connection and the system
+    def connection_info
+      return @get_connection_attributes if @get_connection_attributes
+      conn_info = NWRFCLib::RFCConnection.new
+      rc = NWRFCLib.get_connection_attributes(@handle, conn_info.to_ptr, @error)
+      NWRFC.check_error(@error) if rc > 0
+      @get_connection_attributes = conn_info.members.inject({}) {|hash, member|
+        hash[member] = conn_info[member].get_str #get_str, own definition in nwrfclib.rb, FFI::StructLayout::CharArray#get_str
+        hash
+      }
+    end  
+
+  end
+
+  # Represents a remote-enabled function module for RFC, can be instantiated either by the caller
+  # or by calling Connection#get_function. This only represents the description of the function;
+  # to call a function, an instance of a function call must be obtained with #get_function_call
+  class Function
+    attr_reader :desc, :connection, :function_name
+
+    # Get a function module instance; can also be obtained by calling Connection#get_function
+    def initialize(connection, function_name)
+      @function_name = function_name
+      @error =  NWRFCLib::RFCError.new
+      @desc = NWRFCLib.get_function_desc(connection.handle, function_name.cU, @error.to_ptr)
+      @connection = connection
+      NWRFC.check_error(@error)
+    end
+
+    # Create and return a callable instance of this function module
+    def get_function_call
+      FunctionCall.new(self)
+    end
+
+    # Get the number of parameters this function has
+    def parameter_count
+      pcount = FFI::MemoryPointer.new(:uint)
+      rc = NWRFCLib.get_parameter_count(@desc, pcount, @error)
+      NWRFC.check_error(@error) if rc > 0
+      pcount.read_uint
+    end
+
+  end
+
+  # Representation of a data container (function, structure or table)
+  class DataContainer
+    attr_reader :handle, :desc
+
+    def initialize(handle)
+      @error = NWRFCLib::RFCError.new
+      @handle = handle
+      @desc = NWRFCLib.describe_type(@handle, @error)
+      @member_metadata = {} #Cache of metadata for members
+      NWRFC.check_error(@error)
+    end
+
+    # Return the member specified by string or symbol
+    def [](element)
+      member = element.to_s.upcase
+      metadata = member_metadata(element)
+      case metadata[:type]
+      when :RFCTYPE_CHAR
+        # TODO: Try use :string parameter in get_chars
+        return read_chars(metadata)
+      when :RFCTYPE_DATE
+        return Date.parse(read_chars(metadata))
+        #return Date.new(date[0..3].to_i, date[4..5].to_i, date[6..7].to_i)
+      when :RFCTYPE_BCD
+        size = metadata[:ucLength]
+        cb = FFI::MemoryPointer.new :char, size * 2
+        rc = NWRFCLib.get_chars(@handle, metadata[:name].cU, cb, size * 2, @error.to_ptr)
+        NWRFC.check_error(@error) if rc > 0
+        cb.read_string(size).uC
+      when :RFCTYPE_TIME
+        # TODO: See whether we can optimize this
+        timec = read_chars(metadata)
+        return Time.parse("#{timec[0..1]}:#{timec[2..3]}:#{timec[4..5]}")
+      when :RFCTYPE_BYTE
+        return read_chars(metadata)
+      when :RFCTYPE_TABLE
+        new_handle = NWRFCLib::RFCDataContainer.new
+        rc = NWRFCLib.get_table(@handle, member.cU, new_handle.to_ptr, @error.to_ptr)
+        NWRFC.check_error(@error) if rc > 0
+        # CAVEAT: Other calls using the handle require "handle" field
+        # of the RFC_DATA_CONTAINER struct for some reason.
+        new_handle = new_handle[:handle]
+        value = Table.new(new_handle)
+      when :RFCTYPE_NUM
+        return read_chars(metadata).to_i
+      when :RFCTYPE_FLOAT
+        double = FFI::MemoryPointer.new :double
+        rc = NWRFCLib.get_float(@handle, member.cU, double, @error)
+        NWRFC.check_error(@error) if rc > 0
+        return double.get_double(0)
+      when :RFCTYPE_INT
+        int = FFI::MemoryPointer.new :int
+        rc = NWRFCLib.get_int(@handle, member.cU, int, @error)
+        NWRFC.check_error(@error) if rc > 0
+        return int.get_int(0)
+      when :RFCTYPE_INT2
+        short = FFI::MemoryPointer.new :short
+        rc = NWRFCLib.get_int2(@handle, member.cU, short, @error)
+        NWRFC.check_error(@error) if rc > 0
+        return short.get_short(0)
+      when :RFCTYPE_INT1
+        int1 = FFI::MemoryPointer.new :uint8
+        rc = NWRFCLib.get_int1(@handle, member.cU, int1, @error)
+        NWRFC.check_error(@error) if rc > 0
+        return int1.get_uint8(0)
+      when :RFCTYPE_NULL
+        raise "Unsupported type RFCTYPE_NULL" #You should never run into this
+      when :RFCTYPE_STRUCTURE
+        new_handle = NWRFCLib::RFCDataContainer.new
+        rc = NWRFCLib.get_structure(@handle, member.cU, new_handle.to_ptr, @error.to_ptr)
+        NWRFC.check_error(@error) if rc > 0
+        new_handle = new_handle[:handle]
+        value = Structure.new(new_handle)
+      when :RFCTYPE_DECF16
+        return read_chars(metadata).to_f
+      when :RFCTYPE_DECF34
+        return read_chars(metadata).to_f
+      when :RFCTYPE_XMLDATA
+        raise "Unsupported type RFCTYPE_XMLDATA (no longer used)" #You should never run into this
+      when :RFCTYPE_STRING
+        return read_string(metadata)
+      when :RFCTYPE_XSTRING
+      else
+        raise "Illegal member type #{metadata[:type]}"
+      end
+      NWRFC.check_error(@error)
+      value
+    end
+
+    def []=(element, value)
+      member = element.to_s.upcase
+      metadata = member_metadata(element)
+      case metadata[:type]
+      when :RFCTYPE_CHAR
+        NWRFCLib.set_chars(@handle, member.cU, value.cU, value.length, @error.to_ptr)
+      when :RFCTYPE_DATE
+        value = value_to_date(value)
+        NWRFCLib.set_date(@handle, member.cU, value.cU, @error.to_ptr)
+      when :RFCTYPE_BCD
+      when :RFCTYPE_TIME
+        value = value_to_time(value)
+        NWRFCLib.set_time(@handle, member.cU, value.cU, @error.to_ptr)
+      when :RFCTYPE_BYTE
+      when :RFCTYPE_TABLE
+      when :RFCTYPE_NUM
+      when :RFCTYPE_FLOAT
+        NWRFCLib.set_float(@handle, member.cU, value.to_f, @error.to_ptr)
+        #NWRFCLib.set_chars(@handle, member.cU, value.to_s.cU, value.to_s.length, @error.to_ptr)
+      when :RFCTYPE_INT
+        NWRFCLib.set_int(@handle, member.cU, value.to_i, @error.to_ptr)
+      when :RFCTYPE_INT2
+        NWRFCLib.set_int2(@handle, member.cU, value.to_i, @error.to_ptr)
+      when :RFCTYPE_INT1
+        NWRFCLib.set_int1(@handle, member.cU, value.to_i, @error.to_ptr)
+      when :RFCTYPE_NULL
+        raise "Unsupported type RFCTYPE_NULL" #You should never run into this
+      when :RFCTYPE_STRUCTURE
+      when :RFCTYPE_DECF16
+      when :RFCTYPE_DECF34
+      when :RFCTYPE_XMLDATA
+      when :RFCTYPE_STRING
+      when :RFCTYPE_XSTRING
+      else
+        raise "Illegal member type #{@members[:type]}"
+      end
+      NWRFC.check_error(@error)
+    end
+
+    def value_to_time(value)
+      return value.strftime(NW_TIME_FORMAT) if value.respond_to? :strftime
+      value.to_s
+    end
+
+    def value_to_date(value)
+      return value.strftime(NW_DATE_FORMAT) if value.respond_to? :strftime
+      # Force the resulting string into 8 characters otherwise
+      value = value.to_s
+      value << ' ' until value.size == 8 if value.size < 8
+      value = value[0..7] if value.size > 8
+      value
+    end
+
+    def value_to_time(value)
+      return value.strftime(NW_TIME_FORMAT) if value.respond_to? :strftime
+      # Force the resulting string into 6 characters otherwise
+      value = value.to_s
+      value << ' ' until value.size == 6 if value.size < 6
+      value = value[0..6] if value.size > 6
+      value
+    end
+
+    # Get the metadata of a member (function, structure or table)
+    def member_metadata(member_name)
+      member = member_name.to_s.upcase
+      if self.class == NWRFC::FunctionCall
+        fpar = NWRFCLib::RFCFuncParam.new
+        rc = NWRFCLib.get_parameter_desc_by_name(@desc, member.cU, fpar.to_ptr, @error.to_ptr)
+        NWRFC.check_error(@error) if rc > 0
+        member_to_hash(fpar)
+      elsif self.class == NWRFC::Table || self.class == NWRFC::Structure
+        fd = NWRFCLib::RFCFieldDesc.new
+        rc = NWRFCLib.get_field_desc_by_name(@desc, member.cU, fd.to_ptr, @error.to_ptr)
+        NWRFC.check_error(@error) if rc > 0 
+        member_to_hash(fd)
+      end
+    end
+
+    private
+    # Returns the subset of metadata values common to both a function parameter
+    # and a type field
+    def member_to_hash(member)
+      {
+        :name => member[:name].get_str,
+        :type => NWRFCLib::RFCTYPE[member[:type]],
+        :nucLength => member[:nucLength],
+        :ucLength => member[:ucLength],
+        :decimals => member[:decimals],
+        :typeDescHandle => member[:typeDescHandle]
+      }
+    end
+
+    def read_chars(metadata)
+      size = metadata[:ucLength]
+      cb = FFI::MemoryPointer.new :char, size
+      rc = NWRFCLib.get_chars(@handle, metadata[:name].cU, cb, metadata[:nucLength], @error.to_ptr)
+      NWRFC.check_error(@error) if rc > 0
+      cb.read_string(size).uC
+    end
+
+    def read_string(metadata)
+      #size = metadata[:ucLength]
+      size = FFI::MemoryPointer.new(:uint)
+      rc = NWRFCLib.get_string_length(@handle, metadata[:name].cU, size, @error)
+      NWRFC.check_error(@error) if rc > 0
+      buf_len = size.read_uint + 1
+      sbuf = FFI::MemoryPointer.new :char, buf_len * NWRFCLib::B_SIZE
+      rc = NWRFCLib.get_string(@handle, metadata[:name].cU, sbuf, buf_len, size, @error)
+      NWRFC.check_error(@error) if rc > 0
+      sbuf.read_string(sbuf.size).uC
+    end
+
+  end
+
+  class FunctionCall < DataContainer
+    attr_reader :handle, :desc, :connection, :function
+
+    def initialize(function)
+      @error = NWRFCLib::RFCError.new
+      @function = function
+      @connection = function.connection
+      @handle = NWRFCLib.create_function(@function.desc, @error.to_ptr)
+      @desc = function.desc
+      NWRFC.check_error(@error)
+    end
+
+    def invoke
+      rc = NWRFCLib.invoke(@connection.handle, @handle, @error.to_ptr)
+      NWRFC.check_error(@error) if rc > 0
+    end
+  end
+
+
+  class Table < DataContainer
+
+    include Enumerable
+
+    def each(&block)
+      rc = NWRFCLib.move_to_first_row(@handle, @error)
+      NWRFC.check_error(@error) if rc > 0
+      size.times do |row|
+        struct_handle = NWRFCLib.get_current_row(@handle, @error)
+        NWRFC.check_error(@error)
+        # CAVEAT: Other calls using the handle require "handle" field
+        # of the RFC_DATA_CONTAINER struct
+        yield Structure.new(struct_handle)
+      end
+    end
+
+    def size
+      rows = FFI::MemoryPointer.new(:uint)
+      rc = NWRFCLib.get_row_count(@handle, rows, @error)
+      rows.read_uint
+    end
+
+    # Delete all rows from (empty) the table
+    def clear
+      rc = delete_all_rows(@handle, @error)
+      NWRFC.check_error(@error) if rc > 0
+    end
+
+    # Retrieve the row at the given index
+    def [](index)
+      rc = NWRFCLib.move_to(@handle, index, @error)
+      NWRFC.check_error(@error) if rc > 0
+      struct_handle = NWRFCLib.get_current_row(@handle, @error)
+      NWRFC.check_error(@error)
+      Structure.new(struct_handle)
+    end
+
+  end #class Table
+
+  # Represents a structure. An instance is obtained internally by passing the
+  # handle of a structure. A user can obtain an instance by invoking sub-field
+  # access of a structure or a function
+  class Structure < DataContainer
+
+    # Return a list (array) of symbols representing the names of the fields
+    # of this structure
+    #---
+    # TODO: This is not working!
+    def fields
+      fc = FFI::MemoryPointer.new(:uint)
+      rc = NWRFCLib.get_field_count(@handle, fc, @error)
+      NWRFC.check_error(@error) if rc > 0
+      fc = fc.read_uint
+      fd = NWRFCLib::RFCFieldDesc.new
+      fields = []
+      debugger
+      fc.times do |index|
+        rc = NWRFCLib.get_field_desc_by_index(@handle, index, fd.to_ptr, @error.to_ptr)
+        NWRFC.check_error(@error) if rc > 0
+        fields << fd[:name].get_str.to_sym
+      end
+    end
+    
+  end # class Structure
+
+end #module NWRFC

data/lib/nwrfc/nwrfclib.rb

@@ -0,0 +1,449 @@
+# Author:: Martin Ceronio martin.ceronio@infosize.co.za
+# Copyright:: Copyright (c) 2012 Martin Ceronio
+# License:: MIT and/or Creative Commons Attribution-ShareAlike
+# SAP, Netweaver, RFC and other names referred to in this code
+# are, or may be registered trademarks and the property of SAP, AG
+# No ownership over any of these is asserted by Martin Ceronio
+
+require 'rubygems'
+require 'ffi'
+require 'iconv'
+
+RUBY_VERSION_18 = RUBY_VERSION[0..2] == "1.8"
+
+# Provide an alias for FFI::MemoryPointer#read_int to `read_uint` in 1.8
+# See http://stackoverflow.com/questions/9035661/ruby-ffi-memorypointer-read-int-present-in-1-9-but-not-1-8
+# Probably not good to interpret an unsigned int as an int, but we don't expect to use it for big values
+# that could result in sign conversion
+if RUBY_VERSION_18
+  FFI::MemoryPointer.class_eval{ alias :read_uint :read_int}
+end
+
+# Enhancement to FFI::Pointer to be able to read a double-null terminated string,
+# which would be returned e.g. by RfcGetVersion() in the SDK
+# See http://stackoverflow.com/questions/9293307/ruby-ffi-ruby-1-8-reading-utf-16le-encoded-strings
+module FFI
+  class Pointer
+
+    # Enhancement to FFI::Pointer to be able to read a double-null terminated string,
+    # which would be returned e.g. by RfcGetVersion() in the SDK
+    # See http://stackoverflow.com/questions/9293307/ruby-ffi-ruby-1-8-reading-utf-16le-encoded-strings
+    # It should be safe to call this on a Pointer within the context of the NW RFC SDK library,
+    # because all strings are supposed to be UTF-16LE encoded and double-null terminated
+    def read_string_dn(max=0)
+      cont_nullcount = 0
+      offset = 0
+      until cont_nullcount == 2
+        byte = get_bytes(offset,1)
+        cont_nullcount += 1 if byte == "\000"
+        cont_nullcount = 0 if byte != "\000"
+        offset += 1
+      end
+      get_bytes(0,offset+1)
+    end
+  end
+end
+
+# Enhancement to the String class to put string values into double-null
+# terminated UTF16 little endian encoded strings as required by the NW RFC
+# SDK function, which should work on Linux and Windows (and maybe other
+# architectures, though the plan is not to support them)
+#String.class_eval{define_method(:cU){ Iconv.conv("UTF-16LE", "UTF8", self+"\0") }}
+class String
+  def cU
+    NWRFCLib::Cutf8_to_utf16le.iconv(self+"\0")
+  end
+
+  def uC
+    NWRFCLib::Cutf16le_to_utf8.iconv(self).strip
+  end
+
+end
+#String.class_eval{define_method(:cU){ NWRFCLib::Cutf8_to_utf16le.iconv(self+"\0") }}
+
+# Enhancement to FFI::StructLayout::CharArray to add a get_str method that changes the
+# string value of the character array by enforcing encoding of UTF-16LE (as used in NW RFC SDK)
+# and strips off blanks at the end to return a readable String
+class FFI::StructLayout::CharArray
+  def get_str
+    #Iconv.conv("UTF8", "UTF-16LE", self.to_ptr.read_string(self.size)).strip
+    NWRFCLib::Cutf16le_to_utf8.iconv(self.to_ptr.read_string(self.size)).strip
+  end
+end
+
+# Library wrapper around NW RFC SDK shared library using RUBY-FFI
+# FIXME: Make structs managed structs and deconstruct them on GC
+module NWRFCLib
+
+  Cutf8_to_utf16le = Iconv.new("UTF-16LE", "UTF8")
+  Cutf16le_to_utf8 = Iconv.new("UTF8", "UTF-16LE")
+
+  extend FFI::Library
+  ffi_lib '/home/martin/nwrfcsdk/lib/libsapnwrfc.so'
+
+  # Multiplier for providing correct byte size for String passed to RFC library
+  #TODO: Make platform-dependent size based on RUBY_PLATFORM
+  B_SIZE = 2
+
+  RFC_RC = enum(
+    :RFC_OK,
+    :RFC_COMMUNICATION_FAILURE,
+    :RFC_LOGON_FAILURE,
+    :RFC_ABAP_RUNTIME_FAILURE,
+    :RFC_ABAP_MESSAGE,
+    :RFC_ABAP_EXCEPTION,
+    :RFC_CLOSED,
+    :RFC_CANCELED,
+    :RFC_TIMEOUT,
+    :RFC_MEMORY_INSUFFICIENT,
+    :RFC_VERSION_MISMATCH,
+    :RFC_INVALID_PROTOCOL,
+    :RFC_SERIALIZATION_FAILURE,
+    :RFC_INVALID_HANDLE,
+    :RFC_RETRY,
+    :RFC_EXTERNAL_FAILURE,
+    :RFC_EXECUTED,
+    :RFC_NOT_FOUND,
+    :RFC_NOT_SUPPORTED,
+    :RFC_ILLEGAL_STATE,
+    :RFC_INVALID_PARAMETER,
+    :RFC_CODEPAGE_CONVERSION_FAILURE,
+    :RFC_CONVERSION_FAILURE,
+    :RFC_BUFFER_TOO_SMALL,
+    :RFC_TABLE_MOVE_BOF,
+    :RFC_TABLE_MOVE_EOF,
+    :RFC_UNKNOWN_ERROR
+  )
+
+  RFC_ERROR_GROUP = enum(
+    :OK,
+    :ABAP_APPLICATION_FAILURE,
+    :ABAP_RUNTIME_FAILURE,
+    :LOGON_FAILURE,
+    :COMMUNICATION_FAILURE,
+    :EXTERNAL_RUNTIME_FAILURE,
+    :EXTERNAL_APPLICATION_FAILURE
+  )
+
+  RFC_DIRECTION = enum(
+    :RFC_IMPORT, 1,
+    :RFC_EXPORT, 2,
+    :RFC_CHANGING, 3,
+    :RFC_TABLES, 7
+  )
+
+  RFCTYPE = enum(
+    :RFCTYPE_CHAR   , 0,
+    :RFCTYPE_DATE   , 1,
+    :RFCTYPE_BCD    , 2,
+    :RFCTYPE_TIME   , 3,
+    :RFCTYPE_BYTE   , 4,
+    :RFCTYPE_TABLE   , 5,
+    :RFCTYPE_NUM    , 6,
+    :RFCTYPE_FLOAT  , 7,
+    :RFCTYPE_INT    , 8,
+    :RFCTYPE_INT2   , 9,
+    :RFCTYPE_INT1   , 10,
+    :RFCTYPE_NULL  , 14,
+    :RFCTYPE_STRUCTURE , 17,
+    :RFCTYPE_DECF16  , 23,
+    :RFCTYPE_DECF34  , 24,
+    :RFCTYPE_XMLDATA , 28,
+    :RFCTYPE_STRING , 29,
+    :RFCTYPE_XSTRING , 30
+  )
+
+  # Connection parameter wrapper (struct RFC_CONNECTION_PARAMETER in sapnwrfc.h)
+  class RFCConnParam < FFI::Struct
+    layout :name, :pointer,
+      :value, :pointer
+  end
+
+  # Connection Details (struct RFC_ATTRIBUTES in sapnwrfc.h)
+  class RFCConnection < FFI::Struct
+    layout  :dest,      [:char, (64+1)*B_SIZE],
+      :host,            [:char, (100+1)*B_SIZE],
+      :partnerHost,     [:char, (100+1)*B_SIZE],
+      :sysNumber,       [:char, (2+1)*B_SIZE],
+      :sysId,           [:char, (8+1)*B_SIZE],
+      :client,          [:char, (3+1)*B_SIZE],
+      :user,            [:char, (12+1)*B_SIZE],
+      :language,        [:char, (2+1)*B_SIZE],
+      :trace,           [:char, (1+1)*B_SIZE],
+      :isoLanguage,     [:char, (2+1)*B_SIZE],
+      :codepage,        [:char, (4+1)*B_SIZE],
+      :partnerCodepage, [:char, (4+1)*B_SIZE],
+      :rfcRole,         [:char, (1+1)*B_SIZE],
+      :type,            [:char, (1+1)*B_SIZE],
+      :partnerType,     [:char, (1+1)*B_SIZE],
+      :rel,             [:char, (4+1)*B_SIZE],
+      :partnerRel,      [:char, (4+1)*B_SIZE],
+      :kernelRel,       [:char, (4+1)*B_SIZE],
+      :cpicConvId,      [:char, (8+1)*B_SIZE],
+      :progName,        [:char, (128+1)*B_SIZE],
+      :reserved,        [:char, (86+1)*B_SIZE]
+  end
+
+  # Error info wrapper (struct RFC_ERROR_INFO in sapnwrfc.h)
+  class RFCError < FFI::Struct
+    layout :code,     :int,
+      :group,         :int,
+      :key,           [:char, (128)*B_SIZE],
+      :message,       [:char, (512)*B_SIZE],
+      :abapMsgClass,  [:char, (20+1)*B_SIZE],
+      :abapMsgType,   [:char, (1+1)*B_SIZE],
+      :abapMsgNumber, [:char, (3+1)*B_SIZE],
+      :abapMsgV1,     [:char, (50+1)*B_SIZE],
+      :abapMsgV2,     [:char, (50+1)*B_SIZE],
+      :abapMsgV3,     [:char, (50+1)*B_SIZE],
+      :abapMsgV4,     [:char, (50+1)*B_SIZE] 
+  end
+
+  # Function Parameter Description (struct RFC_PARAMETER_DESC in sapnwrfc.h)
+  class RFCFuncParam < FFI::Struct
+    layout :name,        [:char, (30+1)*B_SIZE],
+      :type,             :int,                   #enum RFCTYPE
+    :direction,          :int,                 #enum RFC_DIRECTION
+    :nucLength,          :uint,
+      :ucLength,           :uint,
+      :decimals,           :uint,
+      :typeDescHandle,     :pointer,               #RFC_TYPE_DESC_HANDLE
+    :defaultValue,     [:char, (30+1)*B_SIZE], #RFC_PARAMETER_DEFVALUE
+    :parameterText,    [:char, (79+1)*B_SIZE], #RFC_PARAMETER_TEXT
+    :optional,         :uchar,                 #RFC_BYTE
+    :extendedDescription, :pointer
+  end
+
+  class RFCFieldDesc < FFI::Struct
+    layout :name, [:char, (30+1)*B_SIZE],
+      :type,             :int,                   #enum RFCTYPE
+      :nucLength,          :uint,
+        :nucOffset,           :uint,
+        :ucLength,           :uint,
+        :ucOffset,           :uint,
+        :decimals,           :uint,
+        :typeDescHandle,     :pointer,              #RFC_TYPE_DESC_HANDLE
+        :extendedDescription, :pointer
+  end
+
+  class RFCDataContainer < FFI::Struct
+    layout :handle, :pointer
+  end
+
+#  typedef :RFCDataContainer, RFCStructureHandle
+#  typedef :RFCDataContainer, RFCTableHandle
+
+  class RFC_FUNCTION_DESC_HANDLE < FFI::Struct
+    layout :handle, :pointer
+  end
+
+  class RFC_TYPE_DESC_HANDLE < FFI::Struct
+    layout :handle, :pointer
+  end
+
+  class DATA_CONTAINER_HANDLE < FFI::Struct
+    layout :handle, :pointer
+  end
+
+  #---
+  #  attach_function :init, :RfcInit, [], :void
+  #  # Connection handling:
+  #  attach_function :open_connection, :RfcOpenConnection,
+  #    [:pointer, :uint, :pointer], :pointer
+  #  attach_function :close_connection, :RfcCloseConnection,
+  #    [:pointer, :pointer], :void #(handle, error)
+  #  attach_function :get_connection_attributes, :RfcGetConnectionAttributes,
+  #    [:pointer, :pointer, :pointer], :void #(conn_handle, conninfo, error)
+  #  # Function Handling & Calling
+  #  attach_function :get_function_desc, :RfcGetFunctionDesc,
+  #    [:pointer, :pointer, :pointer], :pointer #(conn_handle, func_name, error)
+  #  attach_function :create_function, :RfcCreateFunction,
+  #    [:pointer, :pointer], :pointer #(fd_handle, error), :func_handle
+  #  attach_function :invoke, :RfcInvoke,
+  #    [:pointer, :pointer, :pointer], :int #(conn_handle, func_handle, error), RC
+  #  #TODO: Do we want to include RfcDestroyFunction for releasing its memory?
+  #  attach_function :get_param_count, :RfcGetParameterCount,
+  #    [:pointer, :pointer, :pointer], :void #(fd_handle, uint, error)
+  #  attach_function :get_parameter_desc_by_index, :RfcGetParameterDescByIndex,
+  #    [:pointer, :uint, :pointer, :pointer], :void #(fd_handle, idx, param, error)
+  #  # Field Handling
+  #  # RFC_RC RfcGetChars(handle, name, buffer, length, error)
+  #  attach_function :get_chars, :RfcGetChars,
+  #    [:pointer, :pointer, :pointer, :uint, :pointer], :RFC_RC
+  #  # RFC_RC RfcGetChars(handle, name, buffer, length, error)
+  #  attach_function :get_num, :RfcGetNum,
+  #    [:pointer, :pointer, :pointer, :uint, :pointer], :RFC_RC
+  #  # RFC_RC RfcGetDate
+  #  attach_function :get_date, :RfcGetDate,
+  #    [:pointer, :pointer, [:char, 8], :pointer], :RFC_RC
+  #  # RFC_RC RfcGetDate
+  #  attach_function :get_time, :RfcGetTime,
+  #    [:pointer, :pointer, [:char, 6], :pointer], :RFC_RC
+  #  # RFC_RC RfcGetString
+  #  #  attach_function :get_string, :RfcGetString,
+  #  #    [:pointer, :pointer, :pointer], :RFC_RC
+  #  # RFC RfcGetBytes
+  #  attach_function :get_bytes, :RfcGetBytes,
+  #    [:pointer, :pointer, :pointer, :uint, :pointer], :RFC_RC
+  #  # RFC_RC RfcGetXString
+  #  attach_function :get_xstring, :RfcGetXString,
+  #    [:pointer, :pointer, :pointer, :uint, :pointer, :pointer], :RFC_RC
+  #  # RFC_RC RfcGetStringLength(dataHandle, name, *length, error)
+  #  attach_function :get_string_length, :RfcGetStringLength,
+  #    [:pointer, :pointer, :pointer, :pointer], :int
+  #  # void RfcSetChars(dataHandle, name, value, length, error)
+  #  attach_function :set_chars, :RfcSetChars,
+  #    [:pointer, :pointer, :pointer, :uint, :pointer], :void
+  #+++
+
+  #############################################################################################################
+  # ATTACH FUNCTIONS
+  #############################################################################################################
+  [
+    [:add_exception, :RfcAddException, [:pointer, :pointer, :pointer], :int],
+    [:add_function_desc, :RfcAddFunctionDesc, [:pointer, :pointer, :pointer], :int],
+    [:add_parameter, :RfcAddParameter, [:pointer, :pointer, :pointer], :int],
+    [:add_type_desc, :RfcAddTypeDesc, [:pointer, :pointer, :pointer], :int],
+    [:add_type_field, :RfcAddTypeField, [:pointer, :pointer, :pointer], :int],
+    [:append_new_row, :RfcAppendNewRow, [:pointer, :pointer], :pointer],
+    [:append_row, :RfcAppendRow, [:pointer, :pointer, :pointer], :int],
+    [:clone_structure, :RfcCloneStructure, [:pointer, :pointer], :pointer],
+    [:clone_table, :RfcCloneTable, [:pointer, :pointer], :pointer],
+    [:close_connection, :RfcCloseConnection, [:pointer, :pointer], :int],
+    [:confirm_transaction, :RfcConfirmTransaction, [:pointer, :pointer], :int],
+    [:create_function, :RfcCreateFunction, [:pointer, :pointer], :pointer],
+    [:create_function_desc, :RfcCreateFunctionDesc, [:pointer, :pointer], :pointer],
+    [:create_structure, :RfcCreateStructure, [:pointer, :pointer], :pointer],
+    [:create_table, :RfcCreateTable, [:pointer, :pointer], :pointer],
+    [:create_transaction, :RfcCreateTransaction, [:pointer, :pointer, :pointer, :pointer], :pointer],
+    [:create_type_desc, :RfcCreateTypeDesc, [:pointer, :pointer], :pointer],
+    [:delete_all_rows, :RfcDeleteAllRows, [:pointer, :pointer], :int],
+    [:delete_current_row, :RfcDeleteCurrentRow, [:pointer, :pointer], :int],
+    [:describe_function, :RfcDescribeFunction, [:pointer, :pointer], :pointer],
+    [:describe_type, :RfcDescribeType, [:pointer, :pointer], :pointer],
+    [:destroy_function, :RfcDestroyFunction, [:pointer, :pointer], :int],
+    [:destroy_function_desc, :RfcDestroyFunctionDesc, [:pointer, :pointer], :int],
+    [:destroy_structure, :RfcDestroyStructure, [:pointer, :pointer], :int],
+    [:destroy_table, :RfcDestroyTable, [:pointer, :pointer], :int],
+    [:destroy_transaction, :RfcDestroyTransaction, [:pointer, :pointer], :int],
+    [:destroy_type_desc, :RfcDestroyTypeDesc, [:pointer, :pointer], :int],
+    [:enable_basxml, :RfcEnableBASXML, [:pointer, :pointer], :int],
+    [:get_bytes, :RfcGetBytes, [:pointer, :pointer, :pointer, :uint, :pointer], :int],
+    [:get_cached_function_desc, :RfcGetCachedFunctionDesc, [:pointer, :pointer, :pointer], :pointer],
+    [:get_cached_type_desc, :RfcGetCachedTypeDesc, [:pointer, :pointer, :pointer], :pointer],
+    [:get_chars, :RfcGetChars, [:pointer, :pointer, :pointer, :uint, :pointer], :int],
+    [:get_connection_attributes, :RfcGetConnectionAttributes, [:pointer, :pointer, :pointer], :int],
+    [:get_current_row, :RfcGetCurrentRow, [:pointer, :pointer], :pointer],
+    [:get_date, :RfcGetDate, [:pointer, :pointer, :pointer, :pointer], :int],
+    [:get_dec_f16, :RfcGetDecF16, [:pointer, :pointer, :pointer, :pointer], :int],
+    [:get_dec_f34, :RfcGetDecF34, [:pointer, :pointer, :pointer, :pointer], :int],
+    [:get_direction_as_string, :RfcGetDirectionAsString, [:pointer], :pointer],
+    [:get_exception_count, :RfcGetExceptionCount, [:pointer, :pointer, :pointer], :int],
+    [:get_exception_desc_by_index, :RfcGetExceptionDescByIndex, [:pointer, :uint, :pointer, :pointer], :int],
+    [:get_exception_desc_by_name, :RfcGetExceptionDescByName, [:pointer, :pointer, :pointer, :pointer], :int],
+    [:get_field_count, :RfcGetFieldCount, [:pointer, :pointer, :pointer], :int],
+    [:get_field_desc_by_index, :RfcGetFieldDescByIndex, [:pointer, :uint, :pointer, :pointer], :int],
+    [:get_field_desc_by_name, :RfcGetFieldDescByName, [:pointer, :pointer, :pointer, :pointer], :int],
+    [:get_float, :RfcGetFloat, [:pointer, :pointer, :pointer, :pointer], :int],
+    [:get_function_desc, :RfcGetFunctionDesc, [:pointer, :pointer, :pointer], :pointer],
+    [:get_function_name, :RfcGetFunctionName, [:pointer, :pointer, :pointer], :int],
+    [:get_int, :RfcGetInt, [:pointer, :pointer, :pointer, :pointer], :int],
+    [:get_int1, :RfcGetInt1, [:pointer, :pointer, :pointer, :pointer], :int],
+    [:get_int2, :RfcGetInt2, [:pointer, :pointer, :pointer, :pointer], :int],
+    [:get_num, :RfcGetNum, [:pointer, :pointer, :pointer, :uint, :pointer], :int],
+    [:get_parameter_count, :RfcGetParameterCount, [:pointer, :pointer, :pointer], :int],
+    [:get_parameter_desc_by_index, :RfcGetParameterDescByIndex, [:pointer, :uint, :pointer, :pointer], :int],
+    [:get_parameter_desc_by_name, :RfcGetParameterDescByName, [:pointer, :pointer, :pointer, :pointer], :int],
+    [:get_partner_snc_key, :RfcGetPartnerSNCKey, [:pointer, :pointer, :pointer, :pointer], :int],
+    [:get_partner_snc_name, :RfcGetPartnerSNCName, [:pointer, :pointer, :uint, :pointer], :int],
+    [:get_partner_sso_ticket, :RfcGetPartnerSSOTicket, [:pointer, :pointer, :pointer, :pointer], :int],
+    [:get_rc_as_string, :RfcGetRcAsString, [:pointer], :pointer],
+    [:get_row_count, :RfcGetRowCount, [:pointer, :pointer, :pointer], :int],
+    [:get_string, :RfcGetString, [:pointer, :pointer, :pointer, :uint, :pointer, :pointer], :int],
+    [:get_string_length, :RfcGetStringLength, [:pointer, :pointer, :pointer, :pointer], :int],
+    [:get_structure, :RfcGetStructure, [:pointer, :pointer, :pointer, :pointer], :int],
+    [:get_table, :RfcGetTable, [:pointer, :pointer, :pointer, :pointer], :int],
+    [:get_time, :RfcGetTime, [:pointer, :pointer, :pointer, :pointer], :int],
+    [:get_transaction_id, :RfcGetTransactionID, [:pointer, :pointer, :pointer], :int],
+    [:get_type_as_string, :RfcGetTypeAsString, [:pointer], :pointer],
+    [:get_type_desc, :RfcGetTypeDesc, [:pointer, :pointer, :pointer], :pointer],
+    [:get_type_length, :RfcGetTypeLength, [:pointer, :pointer, :pointer, :pointer], :int],
+    [:get_type_name, :RfcGetTypeName, [:pointer, :pointer, :pointer], :int],
+    [:get_version, :RfcGetVersion, [:pointer, :pointer, :pointer], :pointer],
+    [:get_x_string, :RfcGetXString, [:pointer, :pointer, :pointer, :uint, :pointer, :pointer], :int],
+    [:init, :RfcInit, [:pointer], :int],
+    [:insert_new_row, :RfcInsertNewRow, [:pointer, :pointer], :pointer],
+    [:insert_row, :RfcInsertRow, [:pointer, :pointer, :pointer], :int],
+    [:install_generic_server_function, :RfcInstallGenericServerFunction, [:pointer, :pointer, :pointer], :int],
+    [:install_server_function, :RfcInstallServerFunction, [:pointer, :pointer, :pointer, :pointer], :int],
+    [:install_transaction_handlers, :RfcInstallTransactionHandlers, [:pointer, :pointer, :pointer, :pointer, :pointer, :pointer], :int],
+    [:invoke, :RfcInvoke, [:pointer, :pointer, :pointer], :int],
+    [:invoke_in_transaction, :RfcInvokeInTransaction, [:pointer, :pointer, :pointer], :int],
+    [:is_basxml_supported, :RfcIsBASXMLSupported, [:pointer, :pointer, :pointer], :int],
+    #[:is_connection_handle_valid, :RfcIsConnectionHandleValid, [:pointer, :pointer, :pointer], :int],
+    [:is_parameter_active, :RfcIsParameterActive, [:pointer, :pointer, :pointer, :pointer], :int],
+    [:listen_and_dispatch, :RfcListenAndDispatch, [:pointer, :int, :pointer], :int],
+    [:move_to, :RfcMoveTo, [:pointer, :uint, :pointer], :int],
+    [:move_to_first_row, :RfcMoveToFirstRow, [:pointer, :pointer], :int],
+    [:move_to_last_row, :RfcMoveToLastRow, [:pointer, :pointer], :int],
+    [:move_to_next_row, :RfcMoveToNextRow, [:pointer, :pointer], :int],
+    [:move_to_previous_row, :RfcMoveToPreviousRow, [:pointer, :pointer], :int],
+    [:open_connection, :RfcOpenConnection, [:pointer, :uint, :pointer], :pointer],
+    [:ping, :RfcPing, [:pointer, :pointer], :int],
+    [:register_server, :RfcRegisterServer, [:pointer, :uint, :pointer], :pointer],
+    [:reload_ini_file, :RfcReloadIniFile, [:pointer], :int],
+#    [:remove_function_desc, :RfcRemoveFunctionDesc, [:pointer, :pointer, :pointer], :int],
+#    [:remove_type_desc, :RfcRemoveTypeDesc, [:pointer, :pointer, :pointer], :int],
+    [:reset_server_context, :RfcResetServerContext, [:pointer, :pointer], :int],
+    [:sapuc_to_utf8, :RfcSAPUCToUTF8, [:pointer, :uint, :pointer, :pointer, :pointer, :pointer], :int],
+    [:set_bytes, :RfcSetBytes, [:pointer, :pointer, :pointer, :uint, :pointer], :int],
+    [:set_chars, :RfcSetChars, [:pointer, :pointer, :pointer, :uint, :pointer], :int],
+    [:set_date, :RfcSetDate, [:pointer, :pointer, :pointer, :pointer], :int],
+    [:set_dec_f16, :RfcSetDecF16, [:pointer, :pointer, :pointer, :pointer], :int],
+    [:set_dec_f34, :RfcSetDecF34, [:pointer, :pointer, :pointer, :pointer], :int],
+    [:set_float, :RfcSetFloat, [:pointer, :pointer, :double, :pointer], :int],
+    [:set_ini_path, :RfcSetIniPath, [:pointer, :pointer], :int],
+    [:set_int, :RfcSetInt, [:pointer, :pointer, :long, :pointer], :int],
+    [:set_int1, :RfcSetInt1, [:pointer, :pointer, :uint8, :pointer], :int],
+    [:set_int2, :RfcSetInt2, [:pointer, :pointer, :short, :pointer], :int],
+    [:set_num, :RfcSetNum, [:pointer, :pointer, :pointer, :uint, :pointer], :int],
+    [:set_parameter_active, :RfcSetParameterActive, [:pointer, :pointer, :int, :pointer], :int],
+    [:set_string, :RfcSetString, [:pointer, :pointer, :pointer, :uint, :pointer], :int],
+    [:set_structure, :RfcSetStructure, [:pointer, :pointer, :pointer, :pointer], :int],
+    [:set_table, :RfcSetTable, [:pointer, :pointer, :pointer, :pointer], :int],
+    [:set_time, :RfcSetTime, [:pointer, :pointer, :pointer, :pointer], :int],
+    #[:set_trace_dir, :RfcSetTraceDir, [:pointer, :pointer], :int],
+    #[:set_trace_encoding, :RfcSetTraceEncoding, [:pointer, :pointer], :int],
+    #[:set_trace_level, :RfcSetTraceLevel, [:pointer, :pointer, :uint, :pointer], :int],
+    [:set_type_length, :RfcSetTypeLength, [:pointer, :uint, :uint, :pointer], :int],
+    [:set_x_string, :RfcSetXString, [:pointer, :pointer, :pointer, :uint, :pointer], :int],
+    [:snc_key_to_name, :RfcSNCKeyToName, [:pointer, :pointer, :uint, :pointer, :uint, :pointer], :int],
+    [:snc_name_to_key, :RfcSNCNameToKey, [:pointer, :pointer, :pointer, :pointer, :pointer], :int],
+    [:start_server, :RfcStartServer, [:int, :pointer, :pointer, :uint, :pointer], :pointer],
+    [:submit_transaction, :RfcSubmitTransaction, [:pointer, :pointer], :int],
+    [:utf8_to_sapuc, :RfcUTF8ToSAPUC, [:pointer, :uint, :pointer, :pointer, :pointer, :pointer], :int]
+  ].each{|funcsig|
+    #    puts funcsig.to_s
+    attach_function(funcsig[0], funcsig[1], funcsig[2], funcsig[3])
+  }
+
+  # Take Hash of connection parameters and returns FFI pointer to an array
+  # for passing to connection
+  def NWRFCLib.make_conn_params(params) #https://github.com/ffi/ffi/wiki/Structs
+    par = FFI::MemoryPointer.new(RFCConnParam, params.length)
+    pars = params.length.times.collect do |i|
+      RFCConnParam.new(par + i * RFCConnParam.size)
+    end
+    #TODO Optimize this method
+    tpar = params.to_a
+    params.length.times do |n|
+      #      str = (tpar[n][0].to_s + "\0").encode("UTF-16LE")
+      pars[n][:name] = FFI::MemoryPointer.from_string(tpar[n][0].to_s.cU)
+      #      str = (tpar[n][1].to_s + "\0").encode("UTF-16LE")
+      #      str = str.encode("UTF-16LE")
+      pars[n][:value] = FFI::MemoryPointer.from_string(tpar[n][1].to_s.cU)
+    end
+    par
+  end
+
+end