dhcpsapi 0.0.3 → 0.0.4

data/lib/dhcpsapi/common_data_structs.rb

@@ -1,267 +0,0 @@
-module DhcpsApi
-=begin
-  typedef struct _DHCP_IP_ARRAY {
-    DWORD             NumElements;
-    LPDHCP_IP_ADDRESS Elements;
-  } DHCP_IP_ARRAY, *LPDHCP_IP_ARRAY;
-=end
-  class DHCP_IP_ARRAY < DHCPS_Struct
-    layout :num_elements, :uint32,
-           :elements, :pointer
-  end
-
-=begin
-  typedef struct _DHCP_HOST_INFO {
-    DHCP_IP_ADDRESS IpAddress;
-    LPWSTR          NetBiosName;
-    LPWSTR          HostName;
-  } DHCP_HOST_INFO, *LPDHCP_HOST_INFO;
-=end
-  class DHCP_HOST_INFO < DHCPS_Struct
-    layout :ip_address, :uint32,
-           :net_bios_name, :pointer,
-           :host_name, :pointer
-
-    ruby_struct_attr :uint32_to_ip, :ip_address
-    ruby_struct_attr :to_string, :net_bios_name, :host_name
-  end
-
-=begin
-  typedef struct _DHCP_BINARY_DATA {
-    DWORD DataLength;
-    BYTE  *Data;
-  } DHCP_BINARY_DATA, *LPDHCP_BINARY_DATA, DHCP_CLIENT_UID;
-=end
-  class DHCP_CLIENT_UID < DHCPS_Struct
-    layout :data_length, :uint32,
-           :data, :pointer
-
-    def self.from_mac_address(mac_address)
-      to_return = new
-      mac_as_uint8s = to_return.mac_address_to_array_of_uint8(mac_address)
-      to_return[:data_length] = mac_as_uint8s.size
-      to_return[:data] = FFI::MemoryPointer.new(:uint8, mac_as_uint8s.size)
-      to_return[:data].write_array_of_uint8(mac_as_uint8s)
-      to_return
-    end
-
-    def intialize_with_mac_address(mac_address)
-      mac_as_uint8s = mac_address_to_array_of_uint8(mac_address)
-      self[:data_length] = mac_as_uint8s.size
-      self[:data] = FFI::MemoryPointer.new(:uint8, mac_as_uint8s.size)
-      self[:data].write_array_of_uint8(mac_as_uint8s)
-      self
-    end
-
-    def initialize_with_subnet_and_mac_addresses(subnet_address, mac_address)
-      mac_as_uint8s = mac_address_to_array_of_uint8(mac_address)
-      subnet_as_uint8s = subnet_address.split('.').reverse.map {|octet| octet.to_i}
-      self[:data_length] = 11
-      self[:data] = FFI::MemoryPointer.new(:uint8, 11)
-      self[:data].write_array_of_uint8(subnet_as_uint8s + [0x1] + mac_as_uint8s)
-    end
-
-    def data_as_ruby_struct_attr
-      self[:data].read_array_of_type(:uint8, :read_uint8, self[:data_length]).map {|w| "%02X" % w}.join(":")
-    end
-  end
-
-  class DHCP_BINARY_DATA < DHCPS_Struct
-    layout :data_length, :uint32,
-           :data, :pointer
-
-    def self.from_data(data)
-      to_return = new
-      to_return[:data_length] = data.size
-      to_return[:data] = FFI::MemoryPointer.new(:uint8, data.size)
-      to_return[:data].write_array_of_uint8(data)
-      to_return
-    end
-
-    def data_as_ruby_struct_attr
-      self[:data].read_array_of_type(:uint8, :read_uint8, self[:data_length])
-    end
-  end
-
-=begin
-  typedef struct _DATE_TIME {
-    DWORD dwLowDateTime;
-    DWORD dwHighDateTime;
-  } DATE_TIME, *LPDATE_TIME;
-=end
-  class DATE_TIME < DHCPS_Struct
-    layout :dw_low_date_time, :uint32,
-           :dw_high_date_time, :uint32
-
-    def as_ruby_struct
-      tmp = self[:dw_high_date_time]
-      tmp = (tmp << 32) + self[:dw_low_date_time]
-      tmp == 0 ? nil : Time.at(tmp/10000000 - 11644473600)
-    end
-  end
-
-=begin
-  typedef struct _DHCP_CLIENT_SEARCH_INFO {
-    DHCP_SEARCH_INFO_TYPE SearchType;
-    union {
-      DHCP_IP_ADDRESS ClientIpAddress;
-      DHCP_CLIENT_UID ClientHardwareAddress;
-      LPWSTR          ClientName;
-    } SearchInfo;
-  } DHCP_SEARCH_INFO, *LPDHCP_SEARCH_INFO;
-=end
-  class SEARCH_INFO_UNION < FFI::Union
-    layout :client_ip_address, :uint32,
-           :client_hardware_address, DHCP_CLIENT_UID,
-           :client_name, :pointer
-  end
-  class DHCP_SEARCH_INFO < DHCPS_Struct
-    layout :search_type, :uint32, # see DHCP_SEARCH_INFO_TYPE
-           :search_info, SEARCH_INFO_UNION
-  end
-
-  class DWORD_DWORD < DHCPS_Struct
-    layout :dword1, :uint32,
-           :dword2, :uint32
-
-    def self.from_int(an_int)
-      to_return = new
-      to_return[:dword1] = ((an_int >> 32) & 0xffffffff)
-      to_return[:dword2] = (an_int & 0xffffffff)
-      to_return
-    end
-
-    def as_ruby_struct
-      (self[:dword1] << 32) | self[:dword2]
-    end
-  end
-
-=begin
-  typedef struct _DHCP_OPTION_DATA_ELEMENT {
-    DHCP_OPTION_DATA_TYPE OptionType;
-    union {
-      BYTE             ByteOption;
-      WORD             WordOption;
-      DWORD            DWordOption;
-      DWORD_DWORD      DWordDWordOption;
-      DHCP_IP_ADDRESS  IpAddressOption;
-      LPWSTR           StringDataOption;
-      DHCP_BINARY_DATA BinaryDataOption;
-      DHCP_BINARY_DATA EncapsulatedDataOption;
-      LPWSTR           Ipv6AddressDataOption;
-    } Element;
-  } DHCP_OPTION_DATA_ELEMENT, *LPDHCP_OPTION_DATA_ELEMENT;
-=end
-  class DHCP_OPTION_DATA_ELEMENT_UNION < FFI::Union
-    layout :byte_option, :uint8,
-           :word_opition, :uint16,
-           :dword_option, :uint32,
-           :dword_dword_option, DWORD_DWORD,
-           :ip_address_option, :uint32,
-           :string_data_option, :pointer,
-           :binary_data_option, DHCP_BINARY_DATA, # expects an array of uint8s
-           :encapsulated_data_option, DHCP_BINARY_DATA,
-           :ipv6_address_data_option, :pointer
-  end
-
-  class DHCP_OPTION_DATA_ELEMENT < DHCPS_Struct
-    layout :option_type, :uint32, # see DHCP_OPTION_DATA_TYPE
-           :element, DHCP_OPTION_DATA_ELEMENT_UNION
-
-    def element_as_ruby_struct_attr
-      case self[:option_type]
-        when DHCP_OPTION_DATA_TYPE::DhcpByteOption
-          self[:element][:byte_option]
-        when DHCP_OPTION_DATA_TYPE::DhcpWordOption
-          self[:element][:word_opition]
-        when DHCP_OPTION_DATA_TYPE::DhcpDWordOption
-          self[:element][:dword_option]
-        when DHCP_OPTION_DATA_TYPE::DhcpDWordDWordOption
-          self[:element][:dword_dword_option].as_ruby_struct
-        when DHCP_OPTION_DATA_TYPE::DhcpIpAddressOption
-          uint32_to_ip(self[:element][:ip_address_option])
-        when DHCP_OPTION_DATA_TYPE::DhcpStringDataOption
-          to_string(self[:element][:string_data_option])
-        when DHCP_OPTION_DATA_TYPE::DhcpBinaryDataOption
-          self[:element][:binary_data_option].as_ruby_struct
-        when DHCP_OPTION_DATA_TYPE::DhcpEncapsulatedDataOption
-          self[:element][:encapsulated_data_option].as_ruby_struct
-        when DHCP_OPTION_DATA_TYPE::DhcpIpv6AddressOption
-          to_string(self[:element][:ipv6_address_data_option])
-      end
-    end
-
-    def initialize_from_data(type, data)
-      self[:option_type] = type
-      case type
-        when DHCP_OPTION_DATA_TYPE::DhcpByteOption
-          self[:element][:byte_option] = data.nil? ? 0 : data & 0xff
-        when DHCP_OPTION_DATA_TYPE::DhcpWordOption
-          self[:element][:word_opition] = data.nil? ? 0 : data & 0xffff
-        when DHCP_OPTION_DATA_TYPE::DhcpDWordOption
-          self[:element][:dword_option] = data.nil? ? 0 : data & 0xffffffff
-        when DHCP_OPTION_DATA_TYPE::DhcpDWordDWordOption
-          self[:element][:dword_dword_option] = DWORD_DWORD.from_int(data.nil? ? 0 : data)
-        when DHCP_OPTION_DATA_TYPE::DhcpIpAddressOption
-          self[:element][:ip_address_option] = data.nil? ? 0 : ip_to_uint32(data)
-        when DHCP_OPTION_DATA_TYPE::DhcpStringDataOption
-          self[:element][:string_data_option] = FFI::MemoryPointer.from_string(to_wchar_string(data.nil? ? '' : data))
-        when DHCP_OPTION_DATA_TYPE::DhcpBinaryDataOption
-          self[:element][:binary_data_option] = DHCP_BINARY_DATA.from_data(data.nil? ? [0] : data)
-        when DHCP_OPTION_DATA_TYPE::DhcpEncapsulatedDataOption
-          self[:element][:encapsulated_data_option] = DHCP_BINARY_DATA.from_data(data.nil? ? [0] : data)
-        when DHCP_OPTION_DATA_TYPE::DhcpIpv6AddressOption
-          self[:element][:ipv6_address_data_option] = FFI::MemoryPointer.from_string(to_wchar_string(data.nil? ? '' : data))
-        else
-          raise DhcpError, "Unknown dhcp option data type: #{type}"
-      end
-
-      self
-    end
-
-    def self.initialize_from_data(type, data)
-      DHCP_OPTION_DATA_ELEMENT.new.initialize_from_data(type, data)
-    end
-  end
-
-=begin
-  typedef struct _DHCP_OPTION_DATA {
-    DWORD                      NumElements;
-    LPDHCP_OPTION_DATA_ELEMENT Elements;
-  } DHCP_OPTION_DATA, *LPDHCP_OPTION_DATA;
-=end
-  class DHCP_OPTION_DATA < DHCPS_Struct
-    layout :num_elements, :uint32,
-           :elements, :pointer
-
-    def self.from_array(type, array_of_data)
-      to_return = new
-      to_return.from_array(type, array_of_data)
-      to_return
-    end
-
-    def from_array(type, array_of_data)
-      if array_of_data.size == 0
-        self[:num_elements] = 1
-        self[:elements] = FFI::MemoryPointer.new(DHCP_OPTION_DATA_ELEMENT, 1)
-        DHCP_OPTION_DATA_ELEMENT.new(self[:elements]).initialize_from_data(type, nil)
-        return self
-      end
-
-      self[:num_elements] = array_of_data.size
-      self[:elements] = FFI::MemoryPointer.new(DHCP_OPTION_DATA_ELEMENT, array_of_data.size)
-      0.upto(array_of_data.size-1) do |i|
-        element = DHCP_OPTION_DATA_ELEMENT.new(self[:elements] + DHCP_OPTION_DATA_ELEMENT.size*i)
-        element.initialize_from_data(type, array_of_data[i])
-      end
-
-      self
-    end
-
-    def as_ruby_struct
-      0.upto(self[:num_elements]-1).inject([]) do |all, offset|
-        all << DHCP_OPTION_DATA_ELEMENT.new(self[:elements] + DHCP_OPTION_DATA_ELEMENT.size*offset).as_ruby_struct
-      end
-    end
-  end
-end

data/lib/dhcpsapi/ffi.rb

@@ -1,6 +0,0 @@
-module DhcpsApi
-  extend FFI::Library
-
-  ffi_lib 'dhcpsapi'
-  ffi_convention :stdcall
-end

data/lib/dhcpsapi/subnet_element.rb

@@ -1,45 +0,0 @@
-module DhcpsApi
-=begin
-  typedef struct _DHCP_SUBNET_ELEMENT_DATA_V4 {
-    DHCP_SUBNET_ELEMENT_TYPE ElementType;
-    union {
-      DHCP_IP_RANGE          *IpRange;
-      DHCP_HOST_INFO         *SecondaryHost;
-      DHCP_IP_RESERVATION_V4 *ReservedIp;
-      DHCP_IP_RANGE          *ExcludeIpRange;
-      DHCP_IP_CLUSTER        *IpUsedCluster;
-    } Element;
-  } DHCP_SUBNET_ELEMENT_DATA_V4, *LPDHCP_SUBNET_ELEMENT_DATA_V4;
-=end
-  class DHCP_SUBNET_ELEMENT < FFI::Union
-    layout :ip_range, :pointer,
-           :secondary_host, :pointer,
-           :reserved_ip, :pointer,
-           :exclude_ip_range, :pointer,
-           :ip_used_cluster, :pointer
-  end
-
-  class DHCP_SUBNET_ELEMENT_DATA_V4 < DHCPS_Struct
-    layout :element_type, :uint32,
-           :element, DHCP_SUBNET_ELEMENT
-  end
-
-=begin
-  DWORD DhcpAddSubnetElementV4(
-    _In_ DHCP_CONST WCHAR                       *ServerIpAddress,
-    _In_ DHCP_IP_ADDRESS                        SubnetAddress,
-    _In_ DHCP_CONST DHCP_SUBNET_ELEMENT_DATA_V4 *AddElementInfo
-  );
-=end
-  attach_function :DhcpAddSubnetElementV4, [:pointer, :uint32, :pointer], :uint32
-
-=begin
-  DWORD DHCP_API_FUNCTION DhcpRemoveSubnetElementV4(
-    _In_ DHCP_CONST WCHAR                       *ServerIpAddress,
-    _In_ DHCP_IP_ADDRESS                        SubnetAddress,
-    _In_ DHCP_CONST DHCP_SUBNET_ELEMENT_DATA_V4 *RemoveElementInfo,
-    _In_ DHCP_FORCE_FLAG                        ForceFlag
-  );
-=end
-  attach_function :DhcpRemoveSubnetElementV4, [:pointer, :uint32, :pointer, :uint32], :uint32
-end

data/lib/dhcpsapi_for_testing/server.rb

@@ -1,9 +0,0 @@
-module DhcpsApi
-  class Server
-    attr_reader :server_ip_address
-
-    def initialize(server_ip_address)
-      @server_ip_address = server_ip_address
-    end
-  end
-end

data/lib/dhcpsapi_for_testing.rb

@@ -1,3 +0,0 @@
-require 'dhcpsapi/enums'
-require 'dhcpsapi/error'
-require 'dhcpsapi_for_testing/server'