libvirt_ffi 0.6.1 → 0.8.1

data/lib/libvirt/ffi/interface.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Libvirt
+  module FFI
+    module Interface
+      extend ::FFI::Library
+      extend Helpers
+      ffi_lib Util.library_path
+
+      ## Variables
+
+      ## Enums
+
+      # enum virConnectListAllInterfacesFlags
+      enum :list_all_flags, [
+          :INACTIVE, 0x1,
+          :ACTIVE, 0x2
+      ]
+
+      # enum virInterfaceXMLFlags
+      enum :xml_flags, [
+          :INACTIVE, 0x1 # dump inactive interface information
+      ]
+
+      ## Functions
+
+      # int virConnectListAllInterfaces (
+      #   virConnectPtr conn,
+      #   virInterfacePtr ** ifaces,
+      #   unsigned int flags
+      # )
+      attach_function :virConnectListAllInterfaces,
+                      [:pointer, :pointer, :list_all_flags],
+                      :int
+
+      # int virConnectListDefinedInterfaces (
+      #   virConnectPtr conn,
+      #   char ** const names,
+      #   int maxnames
+      # )
+      attach_function :virConnectListDefinedInterfaces,
+                      [:pointer, :pointer, :int],
+                      :int
+
+      # int virConnectListInterfaces (
+      #   virConnectPtr conn,
+      #   char ** const names,
+      #   int maxnames
+      # )
+      attach_function :virConnectListInterfaces,
+                      [:pointer, :pointer, :int],
+                      :int
+
+      # int virConnectNumOfDefinedInterfaces (virConnectPtr conn)
+      attach_function :virConnectNumOfDefinedInterfaces,
+                      [:pointer],
+                      :int
+
+      # int virConnectNumOfInterfaces (virConnectPtr conn)
+      attach_function :virConnectNumOfInterfaces,
+                      [:pointer],
+                      :int
+
+      # int virInterfaceChangeBegin (
+      #   virConnectPtr conn,
+      #   unsigned int flags
+      # )
+      attach_function :virInterfaceChangeBegin,
+                      [:pointer, :uint],
+                      :int
+
+      # int virInterfaceChangeCommit (
+      #   virConnectPtr conn,
+      #   unsigned int flags
+      # )
+      attach_function :virInterfaceChangeCommit,
+                      [:pointer, :uint],
+                      :int
+
+      # int virInterfaceChangeRollback (
+      #   virConnectPtr conn,
+      #   unsigned int flags
+      # )
+      attach_function :virInterfaceChangeRollback,
+                      [:pointer, :uint],
+                      :int
+
+      # int virInterfaceCreate (
+      #   virInterfacePtr iface,
+      #   unsigned int flags
+      # )
+      attach_function :virInterfaceCreate,
+                      [:pointer, :uint],
+                      :int
+
+      # virInterfacePtr  virInterfaceDefineXML (
+      #   virConnectPtr conn,
+      #   const char * xml,
+      #   unsigned int flags
+      # )
+      attach_function :virInterfaceDefineXML,
+                      [:pointer, :string, :uint],
+                      :pointer
+
+      # int virInterfaceDestroy (
+      #   virInterfacePtr iface,
+      #   unsigned int flags
+      # )
+      attach_function :virInterfaceDestroy,
+                      [:pointer, :uint],
+                      :int
+
+      # int virInterfaceFree (virInterfacePtr iface)
+      attach_function :virInterfaceFree,
+                      [:pointer],
+                      :int
+
+      # virConnectPtr virInterfaceGetConnect (virInterfacePtr iface)
+      attach_function :virInterfaceGetConnect,
+                      [:pointer],
+                      :int
+
+      # const char * virInterfaceGetMACString (virInterfacePtr iface)
+      attach_function :virInterfaceGetMACString,
+                      [:pointer],
+                      :string
+
+      # const char * virInterfaceGetName (virInterfacePtr iface)
+      attach_function :virInterfaceGetName,
+                      [:pointer],
+                      :string
+
+      # char * virInterfaceGetXMLDesc (
+      #   virInterfacePtr iface,
+      #   unsigned int flags
+      # )
+      attach_function :virInterfaceGetXMLDesc,
+                      [:pointer, :uint],
+                      :string
+
+      # int virInterfaceIsActive (virInterfacePtr iface)
+      attach_function :virInterfaceIsActive,
+                      [:pointer],
+                      :int
+
+      # virInterfacePtr virInterfaceLookupByMACString (
+      #   virConnectPtr conn,
+      #   const char * macstr
+      # )
+      attach_function :virInterfaceLookupByMACString,
+                      [:pointer, :string],
+                      :pointer
+
+      # virInterfacePtr virInterfaceLookupByName (
+      #   virConnectPtr conn,
+      #   const char * name
+      # )
+      attach_function :virInterfaceLookupByName,
+                      [:pointer, :string],
+                      :pointer
+
+      # int virInterfaceRef (virInterfacePtr iface)
+      attach_function :virInterfaceRef,
+                      [:pointer],
+                      :int
+
+      # int virInterfaceUndefine (virInterfacePtr iface)
+      attach_function :virInterfaceUndefine,
+                      [:pointer],
+                      :int
+
+      ## Helpers
+    end
+  end
+end

data/lib/libvirt/ffi/network.rb

@@ -0,0 +1,392 @@
+# frozen_string_literal: true
+
+module Libvirt
+  module FFI
+    module Network
+      # https://libvirt.org/html/libvirt-libvirt-network.html
+
+      extend ::FFI::Library
+      extend Helpers
+      ffi_lib Util.library_path
+
+      EVENT_ID_TO_CALLBACK = {
+          LIFECYCLE: :virConnectNetworkEventLifecycleCallback
+      }.freeze
+
+      ## Enums
+
+      # enum virConnectListAllNetworksFlags
+      enum :list_all_flags, [
+          :INACTIVE, 0x1,
+          :ACTIVE, 0x2,
+          :PERSISTENT, 0x4,
+          :TRANSIENT, 0x8,
+          :AUTOSTART, 0x10,
+          :NO_AUTOSTART, 0x20
+      ]
+
+      # enum virIPAddrType
+      enum :ip_addr_type, [
+          :IPV4, 0x0,
+          :IPV6, 0x1
+      ]
+
+      # enum virNetworkEventID
+      enum :event_id, [
+          :LIFECYCLE, 0x0 # virConnectNetworkEventLifecycleCallback
+      ]
+
+      # enum virNetworkEventLifecycleType
+      enum :event_lifecycle_type, [
+          :DEFINED, 0x0,
+          :UNDEFINED, 0x1,
+          :STARTED, 0x2,
+          :STOPPED, 0x3
+      ]
+
+      # enum virNetworkUpdateCommand
+      enum :update_command, [
+          :NONE, 0x0, # (invalid)
+          :MODIFY, 0x1, # modify an existing element
+          :DELETE, 0x2, # delete an existing element
+          :ADD_LAST, 0x3, # add an element at end of list
+          :ADD_FIRST, 0x4 # add an element at start of list
+      ]
+
+      # enum virNetworkUpdateFlags
+      enum :update_flags, [
+          :AFFECT_CURRENT, 0x0, # affect live if network is active, config if its not active
+          :AFFECT_LIVE, 0x1, # affect live state of network only
+          :AFFECT_CONFIG, 0x2 # affect persistent config only
+      ]
+
+      # enum virNetworkUpdateSection
+      enum :update_section, [
+          :NONE, 0x0, # (invalid)
+          :BRIDGE, 0x1, # <bridge>
+          :DOMAIN, 0x2, # <domain>
+          :IP, 0x3, # <ip>
+          :IP_DHCP_HOST, 0x4, # <ip>/<dhcp>/<host>
+          :IP_DHCP_RANGE, 0x5, # <ip>/<dhcp>/<range>
+          :FORWARD, 0x6, # <forward>
+          :FORWARD_INTERFACE, 0x7, # <forward>/<interface>
+          :FORWARD_PF, 0x8, # <forward>/<pf>
+          :PORTGROUP, 0x9, # <portgroup>
+          :DNS_HOST, 0xa, # <dns>/<host>
+          :DNS_TXT, 0xb, # <dns>/<txt>
+          :DNS_SRV, 0xc # <dns>/<srv>
+      ]
+
+      # enum virNetworkXMLFlags
+      enum :xml_flags, [
+          :INACTIVE, 0x1 # dump inactive network information
+      ]
+
+      ## Structs
+
+      # struct virNetworkDHCPLease {
+      #   char *   iface # Network interface name
+      #   long long   expirytime # Seconds since epoch
+      #   int   type # virIPAddrType
+      #   char *   mac # MAC address
+      #   char *   iaid # IAID
+      #   char *   ipaddr # IP address
+      #   unsigned int   prefix # IP address prefix
+      #   char *   hostname # Hostname
+      #   char *   clientid # Client ID or DUID
+      # }
+      class DhcpLeaseStruct < ::FFI::Struct
+        layout :iface, :string,
+               :expirytime, :long_long,
+               :type, FFI::Network.enum_type(:ip_addr_type),
+               :mac, :string,
+               :iaid, :string,
+               :ipaddr, :string,
+               :prefix, :uint,
+               :hostname, :string,
+               :clientid, :string
+      end
+
+      ## Callbacks
+
+      # typedef virConnectNetworkEventGenericCallback
+      # void  virConnectNetworkEventGenericCallback  (
+      #   virConnectPtr conn,
+      #   virNetworkPtr net,
+      #   void * opaque
+      # )
+      callback :virConnectNetworkEventGenericCallback,
+               [:pointer, :pointer, :pointer],
+               :void
+
+      # typedef virConnectNetworkEventLifecycleCallback
+      # void  virConnectNetworkEventLifecycleCallback  (
+      #   virConnectPtr conn,
+      #   virNetworkPtr net,
+      #   int event,
+      #   int detail,
+      #   void * opaque
+      # )
+      callback :virConnectNetworkEventLifecycleCallback,
+               [:pointer, :pointer, :event_lifecycle_type, :int, :pointer],
+               :void
+
+      ## Functions
+
+      # int  virConnectListAllNetworks  (
+      #   virConnectPtr conn,
+      #   virNetworkPtr ** nets,
+      #   unsigned int flags
+      # )
+      attach_function :virConnectListAllNetworks,
+                      [:pointer, :pointer, :list_all_flags],
+                      :int
+
+      # int  virConnectListDefinedNetworks  (
+      #   virConnectPtr conn,
+      #   char ** const names,
+      #   int maxnames
+      # )
+      attach_function :virConnectListDefinedNetworks,
+                      [:pointer, :pointer, :int],
+                      :int
+
+      # int  virConnectListNetworks (
+      #   virConnectPtr conn,
+      #   char ** const names,
+      #   int maxnames
+      # )
+      attach_function :virConnectListNetworks,
+                      [:pointer, :pointer, :int],
+                      :int
+
+      # int  virConnectNetworkEventDeregisterAny  (
+      #   virConnectPtr conn,
+      #   int callbackID
+      # )
+      attach_function :virConnectNetworkEventDeregisterAny, [:pointer, :int], :int
+
+      # int  virConnectNetworkEventRegisterAny  (
+      #   virConnectPtr conn,
+      #   virNetworkPtr net,
+      #   int eventID,
+      #   virConnectNetworkEventGenericCallback cb,
+      #   void * opaque,
+      #   virFreeCallback freecb
+      # )
+      attach_function :virConnectNetworkEventRegisterAny,
+                      [:pointer, :pointer, :event_id, :pointer, :pointer, :pointer],
+                      :int
+
+      # int  virConnectNumOfDefinedNetworks (
+      #   virConnectPtr conn
+      # )
+      attach_function :virConnectNumOfDefinedNetworks,
+                      [:pointer],
+                      :int
+
+      # int  virConnectNumOfNetworks (
+      #   virConnectPtr conn
+      # )
+      attach_function :virConnectNumOfNetworks,
+                      [:pointer],
+                      :int
+
+      # int  virNetworkCreate (
+      #   virNetworkPtr network
+      # )
+      attach_function :virNetworkCreate,
+                      [:pointer],
+                      :int
+
+      # virNetworkPtr  virNetworkCreateXML  (
+      #   virConnectPtr conn,
+      #   const char * xmlDesc
+      # )
+      attach_function :virNetworkCreateXML,
+                      [:pointer, :string],
+                      :pointer
+
+      # void  virNetworkDHCPLeaseFree (
+      #   virNetworkDHCPLeasePtr lease
+      # )
+      attach_function :virNetworkDHCPLeaseFree,
+                      [:pointer],
+                      :void
+
+      # virNetworkPtr  virNetworkDefineXML  (
+      #   virConnectPtr conn,
+      #   const char * xml
+      # )
+      attach_function :virNetworkDefineXML,
+                      [:pointer, :string],
+                      :pointer
+
+      # int  virNetworkDestroy (
+      #   virNetworkPtr network
+      # )
+      attach_function :virNetworkDestroy,
+                      [:pointer],
+                      :int
+
+      # int  virNetworkFree (
+      #   virNetworkPtr network
+      # )
+      attach_function :virNetworkFree,
+                      [:pointer],
+                      :int
+
+      # int  virNetworkGetAutostart (
+      #   virNetworkPtr network,
+      #   int * autostart
+      # )
+      attach_function :virNetworkGetAutostart,
+                      [:pointer, :pointer],
+                      :int
+
+      # char * virNetworkGetBridgeName (
+      #   virNetworkPtr network
+      # )
+      attach_function :virNetworkGetBridgeName,
+                      [:pointer],
+                      :string
+
+      # virConnectPtr  virNetworkGetConnect (
+      #   virNetworkPtr net
+      # )
+      attach_function :virNetworkGetConnect,
+                      [:pointer],
+                      :pointer
+
+      # int  virNetworkGetDHCPLeases (
+      #   virNetworkPtr network,
+      #   const char * mac,
+      #   virNetworkDHCPLeasePtr ** leases,
+      #   unsigned int flags
+      # )
+      attach_function :virNetworkGetDHCPLeases,
+                      [:pointer, :string, :pointer, :uint],
+                      :int
+
+      # const char * virNetworkGetName (
+      #   virNetworkPtr network
+      # )
+      attach_function :virNetworkGetName,
+                      [:pointer],
+                      :string
+
+      # int  virNetworkGetUUID  (
+      #   virNetworkPtr network,
+      #   unsigned char * uuid
+      # )
+      attach_function :virNetworkGetUUID,
+                      [:pointer, :pointer],
+                      :int
+
+      # int  virNetworkGetUUIDString (
+      #   virNetworkPtr network,
+      #   char * buf
+      # )
+      attach_function :virNetworkGetUUIDString,
+                      [:pointer, :pointer],
+                      :int
+
+      # char *  virNetworkGetXMLDesc (
+      #   virNetworkPtr network,
+      #   unsigned int flags
+      # )
+      attach_function :virNetworkGetXMLDesc,
+                      [:pointer, :xml_flags],
+                      :string
+
+      # int  virNetworkIsActive (
+      #   virNetworkPtr net
+      # )
+      attach_function :virNetworkIsActive,
+                      [:pointer],
+                      :int
+
+      # int  virNetworkIsPersistent (
+      #   virNetworkPtr net
+      # )
+      attach_function :virNetworkIsPersistent,
+                      [:pointer],
+                      :int
+
+      # virNetworkPtr  virNetworkLookupByName (
+      #   virConnectPtr conn,
+      #   const char * name
+      # )
+      attach_function :virNetworkLookupByName,
+                      [:pointer, :string],
+                      :pointer
+
+      # virNetworkPtr  virNetworkLookupByUUID (
+      #   virConnectPtr conn,
+      #   const unsigned char * uuid
+      # )
+      attach_function :virNetworkLookupByUUID,
+                      [:pointer, :pointer],
+                      :pointer
+
+      # virNetworkPtr  virNetworkLookupByUUIDString (
+      #   virConnectPtr conn,
+      #   const char * uuidstr
+      # )
+      attach_function :virNetworkLookupByUUIDString,
+                      [:pointer, :string],
+                      :pointer
+
+      # int  virNetworkRef (
+      #   virNetworkPtr network
+      # )
+      attach_function :virNetworkRef,
+                      [:pointer],
+                      :int
+
+      # int  virNetworkSetAutostart (
+      #   virNetworkPtr network,
+      #   int autostart
+      # )
+      attach_function :virNetworkSetAutostart,
+                      [:pointer, :int],
+                      :int
+
+      # int  virNetworkUndefine (
+      #   virNetworkPtr network
+      # )
+      attach_function :virNetworkUndefine,
+                      [:pointer],
+                      :int
+
+      # int  virNetworkUpdate (
+      #   virNetworkPtr network,
+      #   unsigned int command,
+      #   unsigned int section,
+      #   int parentIndex,
+      #   const char * xml,
+      #   unsigned int flags
+      # )
+      attach_function :virNetworkUpdate,
+                      [:pointer, :update_command, :update_section, :int, :string, :update_flags],
+                      :int
+
+      ## Helpers
+      module_function
+
+      # Creates event callback function for provided event_id
+      # @param event_id [Integer,Symbol]
+      # @yield connect_ptr, network_ptr, *args, opaque_ptr
+      # @return [FFI::Function]
+      def event_callback_for(event_id, &block)
+        event_id_sym = event_id.is_a?(Symbol) ? event_id : enum_type(:event_id)[event_id]
+
+        callback_name = EVENT_ID_TO_CALLBACK.fetch(event_id_sym)
+        callback_function(callback_name) do |*args|
+          Util.log(:debug, name) { ".event_callback_for #{event_id_sym} CALLBACK #{args.map(&:to_s).join(', ')}," }
+          block.call(*args)
+        end
+      end
+    end
+  end
+end

data/lib/libvirt/ffi/storage.rb

@@ -218,7 +218,7 @@ module Libvirt
 
       # Creates event callback function for provided event_id
       # @param event_id [Integer,Symbol]
-      # @yield connect_ptr, domain_ptr, *args, opaque_ptr
+      # @yield connect_ptr, pool_ptr, *args, opaque_ptr
       # @return [FFI::Function]
       def event_callback_for(event_id, &block)
         event_id_sym = event_id.is_a?(Symbol) ? event_id : enum_type(:event_id)[event_id]

data/lib/libvirt/ffi.rb

@@ -13,5 +13,7 @@ module Libvirt
     require 'libvirt/ffi/event'
     require 'libvirt/ffi/stream'
     require 'libvirt/ffi/storage'
+    require 'libvirt/ffi/network'
+    require 'libvirt/ffi/interface'
   end
 end

data/lib/libvirt/host_callback_storage.rb

@@ -29,12 +29,20 @@ module Libvirt
       [cb_data, cb_data_free_func]
     end
 
-    def store_struct(cb_data, connection_pointer:, callback_id:, cb:, opaque:)
+    def store_struct(cb_data, options)
       dbg { '#store_struct' }
 
+      options.assert_valid_keys(:connection_pointer, :callback_id, :cb, :opaque, :free_func)
+      connection_pointer = options.fetch(:connection_pointer)
+      callback_id = options.fetch(:callback_id)
+      cb = options.fetch(:cb)
+      opaque = options.fetch(:opaque)
+      free_func = options.fetch(:free_func)
       cb_data[:connection_pointer] = connection_pointer
       cb_data[:callback_id] = callback_id
-      @inner_storage[connection_pointer.address][callback_id] = { cb: cb, opaque: opaque, pointer: cb_data.pointer }
+      @inner_storage[connection_pointer.address][callback_id] = {
+          cb: cb, opaque: opaque, pointer: cb_data.pointer, free_func: free_func
+      }
     end
 
     def remove_struct(pointer)

data/lib/libvirt/interface.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Libvirt
+  class Interface
+    # @param pointer [FFI::Pointer]
+    def self.load_ref(pointer)
+      result = FFI::Interface.virInterfaceRef(pointer)
+      raise Errors::LibError, "Couldn't retrieve interface reference" if result.negative?
+
+      new(pointer)
+    end
+
+    # @param pointer [FFI::Pointer]
+    def initialize(pointer)
+      @ptr = pointer
+
+      free = ->(obj_id) do
+        dbg { "Finalize Libvirt::Interface object_id=0x#{obj_id.to_s(16)}, pointer=0x#{@ptr.address.to_s(16)}" }
+        return unless @ptr
+
+        warn "Couldn't free Libvirt::Interface object_id=0x#{obj_id.to_s(16)}, pointer=0x#{@ptr.address.to_s(16)}" if FFI::Interface.virInterfaceFree(@ptr).negative?
+      end
+      ObjectSpace.define_finalizer(self, free)
+    end
+
+    # @return [FFI::Pointer]
+    def to_ptr
+      @ptr
+    end
+
+    # @return [String]
+    # @raise [Libvirt::Errors::LibError]
+    def name
+      result = FFI::Interface.virInterfaceGetName(@ptr)
+      raise Errors::LibError, "Couldn't get interface name" if result.nil?
+
+      result
+    end
+
+    # @return [String]
+    # @raise [Libvirt::Errors::LibError]
+    def mac
+      result = FFI::Interface.virInterfaceGetMACString(@ptr)
+      raise Errors::LibError, "Couldn't get interface mac" if result.nil?
+
+      result
+    end
+
+    # @param options_or_flags [Array<Symbol>,Hash{Symbol=>Boolean},Integer,Symbol,nil]
+    # @raise [Libvirt::Errors::LibError]
+    def xml_desc(options_or_flags = nil)
+      flags = Util.parse_flags options_or_flags, FFI::Interface.enum_type(:xml_flags)
+      result = FFI::Interface.virInterfaceGetXMLDesc(@ptr, flags)
+      raise Errors::LibError, "Couldn't get interface xml desc" if result.nil?
+
+      result
+    end
+
+    # @return [Boolean]
+    # @raise [Libvirt::Errors::LibError]
+    def active?
+      result = FFI::Interface.virInterfaceIsActive(@ptr)
+      raise Errors::LibError, "Couldn't get interface is active" if result.nil?
+
+      result == 1
+    end
+
+    # @raise [Libvirt::Errors::LibError]
+    def start
+      result = FFI::Interface.virInterfaceCreate(@ptr, 0)
+      raise Errors::LibError, "Couldn't start interface" if result.negative?
+    end
+
+    # @raise [Libvirt::Errors::LibError]
+    def destroy
+      result = FFI::Interface.virInterfaceDestroy(@ptr, 0)
+      raise Errors::LibError, "Couldn't destroy interface" if result.negative?
+    end
+
+    # @raise [Libvirt::Errors::LibError]
+    def undefine
+      result = FFI::Interface.virInterfaceUndefine(@ptr)
+      raise Errors::LibError, "Couldn't undefine interface" if result.negative?
+    end
+
+    private
+
+    def dbg(&block)
+      Util.log(:debug, 'Libvirt::Network', &block)
+    end
+  end
+end