ruby-libvirt 0.7.1 → 0.8.1

data/ext/libvirt/domain.c

@@ -23,72 +23,28 @@
 #include <unistd.h>
 #include <ruby.h>
 /* we need to include st.h since ruby 1.8 needs it for RHash */
-#include <st.h>
+#include <ruby/st.h>
 #include <libvirt/libvirt.h>
-#if HAVE_VIRDOMAINQEMUMONITORCOMMAND
 #include <libvirt/libvirt-qemu.h>
-#endif
-#if HAVE_VIRDOMAINLXCOPENNAMESPACE
 #include <libvirt/libvirt-lxc.h>
-#endif
 #include <libvirt/virterror.h>
 #include "common.h"
 #include "connect.h"
 #include "extconf.h"
 #include "stream.h"
 
-#ifndef HAVE_TYPE_VIRTYPEDPARAMETERPTR
-#define VIR_TYPED_PARAM_INT VIR_DOMAIN_SCHED_FIELD_INT
-#define VIR_TYPED_PARAM_UINT VIR_DOMAIN_SCHED_FIELD_UINT
-#define VIR_TYPED_PARAM_LLONG VIR_DOMAIN_SCHED_FIELD_LLONG
-#define VIR_TYPED_PARAM_ULLONG VIR_DOMAIN_SCHED_FIELD_ULLONG
-#define VIR_TYPED_PARAM_DOUBLE VIR_DOMAIN_SCHED_FIELD_DOUBLE
-#define VIR_TYPED_PARAM_BOOLEAN VIR_DOMAIN_SCHED_FIELD_BOOLEAN
-#define VIR_TYPED_PARAM_STRING 7
-
-#define VIR_TYPED_PARAM_FIELD_LENGTH 80
-typedef struct _virTypedParameter virTypedParameter;
-struct _virTypedParameter {
-    char field[VIR_TYPED_PARAM_FIELD_LENGTH];  /* parameter name */
-    int type;   /* parameter type, virTypedParameterType */
-    union {
-        int i;                      /* type is INT */
-        unsigned int ui;            /* type is UINT */
-        long long int l;            /* type is LLONG */
-        unsigned long long int ul;  /* type is ULLONG */
-        double d;                   /* type is DOUBLE */
-        char b;                     /* type is BOOLEAN */
-        char *s;                    /* type is STRING, may not be NULL */
-    } value; /* parameter value */
-};
-typedef virTypedParameter *virTypedParameterPtr;
-
-#endif
-
 static VALUE c_domain;
 static VALUE c_domain_info;
 static VALUE c_domain_ifinfo;
 VALUE c_domain_security_label;
 static VALUE c_domain_block_stats;
-#if HAVE_TYPE_VIRDOMAINBLOCKINFOPTR
 static VALUE c_domain_block_info;
-#endif
-#if HAVE_TYPE_VIRDOMAINMEMORYSTATPTR
 static VALUE c_domain_memory_stats;
-#endif
-#if HAVE_TYPE_VIRDOMAINSNAPSHOTPTR
 static VALUE c_domain_snapshot;
-#endif
-#if HAVE_TYPE_VIRDOMAINJOBINFOPTR
 static VALUE c_domain_job_info;
-#endif
 static VALUE c_domain_vcpuinfo;
-#if HAVE_VIRDOMAINGETCONTROLINFO
 static VALUE c_domain_control_info;
-#endif
-#if HAVE_TYPE_VIRDOMAINBLOCKJOBINFOPTR
 static VALUE c_domain_block_job_info;
-#endif
 
 static void domain_free(void *d)
 {
@@ -129,7 +85,7 @@ static void domain_input_to_fixnum_and_flags(VALUE in, VALUE *hash, VALUE *flags
  * call-seq:
  *   dom.migrate(dconn, flags=0, dname=nil, uri=nil, bandwidth=0) -> Libvirt::Domain
  *
- * Call virDomainMigrate[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrate]
+ * Call virDomainMigrate[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrate]
  * to migrate a domain from the host on this connection to the connection
  * referenced in dconn.
  */
@@ -154,12 +110,11 @@ static VALUE libvirt_domain_migrate(int argc, VALUE *argv, VALUE d)
     return ruby_libvirt_domain_new(ddom, dconn);
 }
 
-#if HAVE_VIRDOMAINMIGRATETOURI
 /*
  * call-seq:
  *   dom.migrate_to_uri(duri, flags=0, dname=nil, bandwidth=0) -> nil
  *
- * Call virDomainMigrateToURI[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateToURI]
+ * Call virDomainMigrateToURI[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateToURI]
  * to migrate a domain from the host on this connection to the host whose
  * libvirt URI is duri.
  */
@@ -176,14 +131,12 @@ static VALUE libvirt_domain_migrate_to_uri(int argc, VALUE *argv, VALUE d)
                                    ruby_libvirt_get_cstring_or_null(dname),
                                    ruby_libvirt_value_to_ulong(bandwidth));
 }
-#endif
 
-#if HAVE_VIRDOMAINMIGRATESETMAXDOWNTIME
 /*
  * call-seq:
  *   dom.migrate_set_max_downtime(downtime, flags=0) -> nil
  *
- * Call virDomainMigrateSetMaxDowntime[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateSetMaxDowntime]
+ * Call virDomainMigrateSetMaxDowntime[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateSetMaxDowntime]
  * to set the maximum downtime desired for live migration.  Deprecated; use
  * dom.migrate_max_downtime= instead.
  */
@@ -205,7 +158,7 @@ static VALUE libvirt_domain_migrate_set_max_downtime(int argc, VALUE *argv,
  * call-seq:
  *   dom.migrate_max_downtime = downtime,flags=0
  *
- * Call virDomainMigrateSetMaxDowntime[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateSetMaxDowntime]
+ * Call virDomainMigrateSetMaxDowntime[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateSetMaxDowntime]
  * to set the maximum downtime desired for live migration.
  */
 static VALUE libvirt_domain_migrate_max_downtime_equal(VALUE d, VALUE in)
@@ -220,14 +173,12 @@ static VALUE libvirt_domain_migrate_max_downtime_equal(VALUE d, VALUE in)
                                    NUM2ULL(downtime),
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINMIGRATE2
 /*
  * call-seq:
  *   dom.migrate2(dconn, dxml=nil, flags=0, dname=nil, uri=nil, bandwidth=0) -> Libvirt::Domain
  *
- * Call virDomainMigrate2[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrate2]
+ * Call virDomainMigrate2[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrate2]
  * to migrate a domain from the host on this connection to the connection
  * referenced in dconn.
  */
@@ -257,7 +208,7 @@ static VALUE libvirt_domain_migrate2(int argc, VALUE *argv, VALUE d)
  * call-seq:
  *   dom.migrate_to_uri2(duri=nil, migrate_uri=nil, dxml=nil, flags=0, dname=nil, bandwidth=0) -> nil
  *
- * Call virDomainMigrateToURI2[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateToURI2]
+ * Call virDomainMigrateToURI2[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateToURI2]
  * to migrate a domain from the host on this connection to the host whose
  * libvirt URI is duri.
  */
@@ -283,7 +234,7 @@ static VALUE libvirt_domain_migrate_to_uri2(int argc, VALUE *argv, VALUE d)
  * call-seq:
  *   dom.migrate_set_max_speed(bandwidth, flags=0) -> nil
  *
- * Call virDomainMigrateSetMaxSpeed[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateSetMaxSpeed]
+ * Call virDomainMigrateSetMaxSpeed[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateSetMaxSpeed]
  * to set the maximum bandwidth allowed for live migration.  Deprecated; use
  * dom.migrate_max_speed= instead.
  */
@@ -305,7 +256,7 @@ static VALUE libvirt_domain_migrate_set_max_speed(int argc, VALUE *argv,
  * call-seq:
  *   dom.migrate_max_speed = bandwidth,flags=0
  *
- * Call virDomainMigrateSetMaxSpeed[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateSetMaxSpeed]
+ * Call virDomainMigrateSetMaxSpeed[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateSetMaxSpeed]
  * to set the maximum bandwidth allowed for live migration.
  */
 static VALUE libvirt_domain_migrate_max_speed_equal(VALUE d, VALUE in)
@@ -320,13 +271,12 @@ static VALUE libvirt_domain_migrate_max_speed_equal(VALUE d, VALUE in)
                                    NUM2ULONG(bandwidth),
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
 /*
  * call-seq:
  *   dom.shutdown(flags=0) -> nil
  *
- * Call virDomainShutdown[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainShutdown]
+ * Call virDomainShutdown[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainShutdown]
  * to do a soft shutdown of the domain.  The mechanism for doing the shutdown
  * is hypervisor specific, and may require software running inside the domain
  * to succeed.
@@ -337,27 +287,23 @@ static VALUE libvirt_domain_shutdown(int argc, VALUE *argv, VALUE d)
 
     rb_scan_args(argc, argv, "01", &flags);
 
-#if HAVE_VIRDOMAINSHUTDOWNFLAGS
-    ruby_libvirt_generate_call_nil(virDomainShutdownFlags,
-                                   ruby_libvirt_connect_get(d),
-                                   ruby_libvirt_domain_get(d),
-                                   ruby_libvirt_value_to_uint(flags));
-#else
     if (ruby_libvirt_value_to_uint(flags) != 0) {
-        rb_raise(e_NoSupportError, "Non-zero flags not supported");
+        ruby_libvirt_generate_call_nil(virDomainShutdownFlags,
+                                       ruby_libvirt_connect_get(d),
+                                       ruby_libvirt_domain_get(d),
+                                       ruby_libvirt_value_to_uint(flags));
+    } else {
+        ruby_libvirt_generate_call_nil(virDomainShutdown,
+                                       ruby_libvirt_connect_get(d),
+                                       ruby_libvirt_domain_get(d));
     }
-
-    ruby_libvirt_generate_call_nil(virDomainShutdown,
-                                   ruby_libvirt_connect_get(d),
-                                   ruby_libvirt_domain_get(d));
-#endif
 }
 
 /*
  * call-seq:
  *   dom.reboot(flags=0) -> nil
  *
- * Call virDomainReboot[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainReboot]
+ * Call virDomainReboot[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainReboot]
  * to do a reboot of the domain.
  */
 static VALUE libvirt_domain_reboot(int argc, VALUE *argv, VALUE d)
@@ -375,7 +321,7 @@ static VALUE libvirt_domain_reboot(int argc, VALUE *argv, VALUE d)
  * call-seq:
  *   dom.destroy(flags=0) -> nil
  *
- * Call virDomainDestroy[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainDestroy]
+ * Call virDomainDestroy[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainDestroy]
  * to do a hard power-off of the domain.
  */
 static VALUE libvirt_domain_destroy(int argc, VALUE *argv, VALUE d)
@@ -384,26 +330,23 @@ static VALUE libvirt_domain_destroy(int argc, VALUE *argv, VALUE d)
 
     rb_scan_args(argc, argv, "01", &flags);
 
-#if HAVE_VIRDOMAINDESTROYFLAGS
-    ruby_libvirt_generate_call_nil(virDomainDestroyFlags,
-                                   ruby_libvirt_connect_get(d),
-                                   ruby_libvirt_domain_get(d),
-                                   ruby_libvirt_value_to_uint(flags));
-#else
     if (ruby_libvirt_value_to_uint(flags) != 0) {
-        rb_raise(e_NoSupportError, "Non-zero flags not supported");
+        ruby_libvirt_generate_call_nil(virDomainDestroyFlags,
+                                       ruby_libvirt_connect_get(d),
+                                       ruby_libvirt_domain_get(d),
+                                       ruby_libvirt_value_to_uint(flags));
+    } else {
+        ruby_libvirt_generate_call_nil(virDomainDestroy,
+                                       ruby_libvirt_connect_get(d),
+                                       ruby_libvirt_domain_get(d));
     }
-    ruby_libvirt_generate_call_nil(virDomainDestroy,
-                                   ruby_libvirt_connect_get(d),
-                                   ruby_libvirt_domain_get(d));
-#endif
 }
 
 /*
  * call-seq:
  *   dom.suspend -> nil
  *
- * Call virDomainSuspend[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSuspend]
+ * Call virDomainSuspend[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSuspend]
  * to stop the domain from executing.  The domain will still continue to
  * consume memory, but will not take any CPU time.
  */
@@ -418,7 +361,7 @@ static VALUE libvirt_domain_suspend(VALUE d)
  * call-seq:
  *   dom.resume -> nil
  *
- * Call virDomainResume[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainResume]
+ * Call virDomainResume[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainResume]
  * to resume a suspended domain.  After this call the domain will start
  * consuming CPU resources again.
  */
@@ -432,7 +375,7 @@ static VALUE libvirt_domain_resume(VALUE d)
  * call-seq:
  *   dom.save(filename, dxml=nil, flags=0) -> nil
  *
- * Call virDomainSave[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSave]
+ * Call virDomainSave[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSave]
  * to save the domain state to filename.  After this call, the domain will no
  * longer be consuming any resources.
  */
@@ -442,32 +385,26 @@ static VALUE libvirt_domain_save(int argc, VALUE *argv, VALUE d)
 
     rb_scan_args(argc, argv, "12", &to, &dxml, &flags);
 
-#if HAVE_VIRDOMAINSAVEFLAGS
-    ruby_libvirt_generate_call_nil(virDomainSaveFlags,
-                                   ruby_libvirt_connect_get(d),
-                                   ruby_libvirt_domain_get(d),
-                                   StringValueCStr(to),
-                                   ruby_libvirt_get_cstring_or_null(dxml),
-                                   ruby_libvirt_value_to_uint(flags));
-#else
-    if (TYPE(dxml) != T_NIL) {
-        rb_raise(e_NoSupportError, "Non-nil dxml not supported");
+    if (ruby_libvirt_value_to_uint(flags) != 0 || TYPE(dxml) != T_NIL) {
+        ruby_libvirt_generate_call_nil(virDomainSaveFlags,
+                                       ruby_libvirt_connect_get(d),
+                                       ruby_libvirt_domain_get(d),
+                                       StringValueCStr(to),
+                                       ruby_libvirt_get_cstring_or_null(dxml),
+                                       ruby_libvirt_value_to_uint(flags));
+    } else {
+        ruby_libvirt_generate_call_nil(virDomainSave,
+                                       ruby_libvirt_connect_get(d),
+                                       ruby_libvirt_domain_get(d),
+                                       StringValueCStr(to));
     }
-    if (ruby_libvirt_value_to_uint(flags) != 0) {
-        rb_raise(e_NoSupportError, "Non-zero flags not supported");
-    }
-    ruby_libvirt_generate_call_nil(virDomainSave, ruby_libvirt_connect_get(d),
-                                   ruby_libvirt_domain_get(d),
-                                   StringValueCStr(to));
-#endif
 }
 
-#if HAVE_VIRDOMAINMANAGEDSAVE
 /*
  * call-seq:
  *   dom.managed_save(flags=0) -> nil
  *
- * Call virDomainManagedSave[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainManagedSave]
+ * Call virDomainManagedSave[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainManagedSave]
  * to do a managed save of the domain.  The domain will be saved to a place
  * of libvirt's choosing.
  */
@@ -487,7 +424,7 @@ static VALUE libvirt_domain_managed_save(int argc, VALUE *argv, VALUE d)
  * call-seq:
  *   dom.has_managed_save?(flags=0) -> [True|False]
  *
- * Call virDomainHasManagedSaveImage[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainHasManagedSaveImage]
+ * Call virDomainHasManagedSaveImage[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainHasManagedSaveImage]
  * to determine if a particular domain has a managed save image.
  */
 static VALUE libvirt_domain_has_managed_save(int argc, VALUE *argv, VALUE d)
@@ -506,7 +443,7 @@ static VALUE libvirt_domain_has_managed_save(int argc, VALUE *argv, VALUE d)
  * call-seq:
  *   dom.managed_save_remove(flags=0) -> nil
  *
- * Call virDomainManagedSaveRemove[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainManagedSaveRemove]
+ * Call virDomainManagedSaveRemove[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainManagedSaveRemove]
  * to remove the managed save image for a domain.
  */
 static VALUE libvirt_domain_managed_save_remove(int argc, VALUE *argv, VALUE d)
@@ -520,13 +457,12 @@ static VALUE libvirt_domain_managed_save_remove(int argc, VALUE *argv, VALUE d)
                                    ruby_libvirt_domain_get(d),
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
 /*
  * call-seq:
  *   dom.core_dump(filename, flags=0) -> nil
  *
- * Call virDomainCoreDump[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainCoreDump]
+ * Call virDomainCoreDump[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainCoreDump]
  * to do a full memory dump of the domain to filename.
  */
 static VALUE libvirt_domain_core_dump(int argc, VALUE *argv, VALUE d)
@@ -546,7 +482,7 @@ static VALUE libvirt_domain_core_dump(int argc, VALUE *argv, VALUE d)
  * call-seq:
  *   Libvirt::Domain::restore(conn, filename) -> nil
  *
- * Call virDomainRestore[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainRestore]
+ * Call virDomainRestore[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainRestore]
  * to restore the domain from the filename.
  */
 static VALUE libvirt_domain_s_restore(VALUE RUBY_LIBVIRT_UNUSED(klass), VALUE c,
@@ -562,7 +498,7 @@ static VALUE libvirt_domain_s_restore(VALUE RUBY_LIBVIRT_UNUSED(klass), VALUE c,
  * call-seq:
  *   dom.info -> Libvirt::Domain::Info
  *
- * Call virDomainGetInfo[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetInfo]
+ * Call virDomainGetInfo[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetInfo]
  * to retrieve domain information.
  */
 static VALUE libvirt_domain_info(VALUE d)
@@ -585,12 +521,11 @@ static VALUE libvirt_domain_info(VALUE d)
     return result;
 }
 
-#if HAVE_VIRDOMAINGETSECURITYLABEL
 /*
  * call-seq:
  *   dom.security_label -> Libvirt::Domain::SecurityLabel
  *
- * Call virDomainGetSecurityLabel[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetSecurityLabel]
+ * Call virDomainGetSecurityLabel[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetSecurityLabel]
  * to retrieve the security label applied to this domain.
  */
 static VALUE libvirt_domain_security_label(VALUE d)
@@ -610,13 +545,12 @@ static VALUE libvirt_domain_security_label(VALUE d)
 
     return result;
 }
-#endif
 
 /*
  * call-seq:
  *   dom.block_stats(path) -> Libvirt::Domain::BlockStats
  *
- * Call virDomainBlockStats[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockStats]
+ * Call virDomainBlockStats[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockStats]
  * to retrieve statistics about domain block device path.
  */
 static VALUE libvirt_domain_block_stats(VALUE d, VALUE path)
@@ -640,12 +574,11 @@ static VALUE libvirt_domain_block_stats(VALUE d, VALUE path)
     return result;
 }
 
-#if HAVE_TYPE_VIRDOMAINMEMORYSTATPTR
 /*
  * call-seq:
  *   dom.memory_stats(flags=0) -> [ Libvirt::Domain::MemoryStats ]
  *
- * Call virDomainMemoryStats[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainMemoryStats]
+ * Call virDomainMemoryStats[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMemoryStats]
  * to retrieve statistics about the amount of memory consumed by a domain.
  */
 static VALUE libvirt_domain_memory_stats(int argc, VALUE *argv, VALUE d)
@@ -682,14 +615,12 @@ static VALUE libvirt_domain_memory_stats(int argc, VALUE *argv, VALUE d)
 
     return result;
 }
-#endif
 
-#if HAVE_TYPE_VIRDOMAINBLOCKINFOPTR
 /*
  * call-seq:
  *   dom.blockinfo(path, flags=0) -> Libvirt::Domain::BlockInfo
  *
- * Call virDomainGetBlockInfo[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetBlockInfo]
+ * Call virDomainGetBlockInfo[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetBlockInfo]
  * to retrieve information about the backing file path for the domain.
  */
 static VALUE libvirt_domain_block_info(int argc, VALUE *argv, VALUE d)
@@ -713,14 +644,12 @@ static VALUE libvirt_domain_block_info(int argc, VALUE *argv, VALUE d)
 
     return result;
 }
-#endif
 
-#if HAVE_VIRDOMAINBLOCKPEEK
 /*
  * call-seq:
  *   dom.block_peek(path, offset, size, flags=0) -> String
  *
- * Call virDomainBlockPeek[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockPeek]
+ * Call virDomainBlockPeek[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockPeek]
  * to read size number of bytes, starting at offset offset from domain backing
  * file path.  Due to limitations of the libvirt remote protocol, the user
  * should never request more than 64k bytes.
@@ -743,14 +672,12 @@ static VALUE libvirt_domain_block_peek(int argc, VALUE *argv, VALUE d)
 
     return rb_str_new(buffer, NUM2UINT(size));
 }
-#endif
 
-#if HAVE_VIRDOMAINMEMORYPEEK
 /*
  * call-seq:
  *   dom.memory_peek(start, size, flags=Libvirt::Domain::MEMORY_VIRTUAL) -> String
  *
- * Call virDomainMemoryPeek[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainMemoryPeek]
+ * Call virDomainMemoryPeek[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMemoryPeek]
  * to read size number of bytes from offset start from the domain memory.
  * Due to limitations of the libvirt remote protocol, the user
  * should never request more than 64k bytes.
@@ -776,12 +703,11 @@ static VALUE libvirt_domain_memory_peek(int argc, VALUE *argv, VALUE d)
 
     return rb_str_new(buffer, NUM2UINT(size));
 }
-#endif
 
 /* call-seq:
  *   dom.vcpus -> [ Libvirt::Domain::VCPUInfo ]
  *
- * Call virDomainGetVcpus[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetVcpus]
+ * Call virDomainGetVcpus[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetVcpus]
  * to retrieve detailed information about the state of a domain's virtual CPUs.
  */
 static VALUE libvirt_domain_vcpus(VALUE d)
@@ -803,12 +729,11 @@ static VALUE libvirt_domain_vcpus(VALUE d)
 
     cpumaplen = VIR_CPU_MAPLEN(maxcpus);
 
-    cpumap = alloca(sizeof(unsigned char) * cpumaplen);
+    cpumap = alloca(sizeof(unsigned char) * cpumaplen * dominfo.nrVirtCpu);
 
     r = virDomainGetVcpus(ruby_libvirt_domain_get(d), cpuinfo,
                           dominfo.nrVirtCpu, cpumap, cpumaplen);
     if (r < 0) {
-#if HAVE_VIRDOMAINGETVCPUPININFO
         /* if the domain is not shutoff, then this is an error */
         ruby_libvirt_raise_error_if(dominfo.state != VIR_DOMAIN_SHUTOFF,
                                     e_RetrieveError, "virDomainGetVcpus",
@@ -823,24 +748,20 @@ static VALUE libvirt_domain_vcpus(VALUE d)
         ruby_libvirt_raise_error_if(r < 0, e_RetrieveError,
                                     "virDomainGetVcpuPinInfo",
                                     ruby_libvirt_connect_get(d));
-
-#else
-        ruby_libvirt_raise_error_if(r < 0, e_RetrieveError, "virDomainGetVcpus",
-                                    ruby_libvirt_connect_get(d));
-#endif
     }
 
     result = rb_ary_new();
 
-    for (i = 0; i < dominfo.nrVirtCpu; i++) {
+    for (i = 0; i < r; i++) {
         vcpuinfo = rb_class_new_instance(0, NULL, c_domain_vcpuinfo);
-        rb_iv_set(vcpuinfo, "@number", UINT2NUM(i));
         if (cpuinfo != NULL) {
+            rb_iv_set(vcpuinfo, "@number", INT2NUM(cpuinfo[i].number));
             rb_iv_set(vcpuinfo, "@state", INT2NUM(cpuinfo[i].state));
             rb_iv_set(vcpuinfo, "@cpu_time", ULL2NUM(cpuinfo[i].cpuTime));
             rb_iv_set(vcpuinfo, "@cpu", INT2NUM(cpuinfo[i].cpu));
         }
         else {
+            rb_iv_set(vcpuinfo, "@number", Qnil);
             rb_iv_set(vcpuinfo, "@state", Qnil);
             rb_iv_set(vcpuinfo, "@cpu_time", Qnil);
             rb_iv_set(vcpuinfo, "@cpu", Qnil);
@@ -860,12 +781,11 @@ static VALUE libvirt_domain_vcpus(VALUE d)
     return result;
 }
 
-#if HAVE_VIRDOMAINISACTIVE
 /*
  * call-seq:
  *   dom.active? -> [true|false]
  *
- * Call virDomainIsActive[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainIsActive]
+ * Call virDomainIsActive[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainIsActive]
  * to determine if this domain is currently active.
  */
 static VALUE libvirt_domain_active_p(VALUE d)
@@ -874,14 +794,12 @@ static VALUE libvirt_domain_active_p(VALUE d)
                                          ruby_libvirt_connect_get(d),
                                          ruby_libvirt_domain_get(d));
 }
-#endif
 
-#if HAVE_VIRDOMAINISPERSISTENT
 /*
  * call-seq:
  *   dom.persistent? -> [true|false]
  *
- * Call virDomainIsPersistent[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainIsPersistent]
+ * Call virDomainIsPersistent[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainIsPersistent]
  * to determine if this is a persistent domain.
  */
 static VALUE libvirt_domain_persistent_p(VALUE d)
@@ -890,13 +808,12 @@ static VALUE libvirt_domain_persistent_p(VALUE d)
                                          ruby_libvirt_connect_get(d),
                                          ruby_libvirt_domain_get(d));
 }
-#endif
 
 /*
  * call-seq:
  *   dom.ifinfo(if) -> Libvirt::Domain::IfInfo
  *
- * Call virDomainInterfaceStats[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainInterfaceStats]
+ * Call virDomainInterfaceStats[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainInterfaceStats]
  * to retrieve statistics about domain interface if.
  */
 static VALUE libvirt_domain_if_stats(VALUE d, VALUE sif)
@@ -930,7 +847,7 @@ static VALUE libvirt_domain_if_stats(VALUE d, VALUE sif)
  * call-seq:
  *   dom.name -> String
  *
- * Call virDomainGetName[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetName]
+ * Call virDomainGetName[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetName]
  * to retrieve the name of this domain.
  */
 static VALUE libvirt_domain_name(VALUE d)
@@ -944,7 +861,7 @@ static VALUE libvirt_domain_name(VALUE d)
  * call-seq:
  *   dom.id -> Fixnum
  *
- * Call virDomainGetID[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetID]
+ * Call virDomainGetID[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetID]
  * to retrieve the ID of this domain.  If the domain isn't running, this will
  * be -1.
  */
@@ -969,7 +886,7 @@ static VALUE libvirt_domain_id(VALUE d)
  * call-seq:
  *   dom.uuid -> String
  *
- * Call virDomainGetUUIDString[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetUUIDString]
+ * Call virDomainGetUUIDString[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetUUIDString]
  * to retrieve the UUID of this domain.
  */
 static VALUE libvirt_domain_uuid(VALUE d)
@@ -983,7 +900,7 @@ static VALUE libvirt_domain_uuid(VALUE d)
  * call-seq:
  *   dom.os_type -> String
  *
- * Call virDomainGetOSType[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetOSType]
+ * Call virDomainGetOSType[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetOSType]
  * to retrieve the os_type of this domain.  In libvirt terms, os_type determines
  * whether this domain is fully virtualized, paravirtualized, or a container.
  */
@@ -998,7 +915,7 @@ static VALUE libvirt_domain_os_type(VALUE d)
  * call-seq:
  *   dom.max_memory -> Fixnum
  *
- * Call virDomainGetMaxMemory[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetMaxMemory]
+ * Call virDomainGetMaxMemory[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetMaxMemory]
  * to retrieve the maximum amount of memory this domain is allowed to access.
  * Note that the current amount of memory this domain is allowed to access may
  * be different (see dom.memory_set).
@@ -1019,7 +936,7 @@ static VALUE libvirt_domain_max_memory(VALUE d)
  * call-seq:
  *   dom.max_memory = Fixnum
  *
- * Call virDomainSetMaxMemory[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetMaxMemory]
+ * Call virDomainSetMaxMemory[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetMaxMemory]
  * to set the maximum amount of memory (in kilobytes) this domain should be
  * allowed to access.
  */
@@ -1040,7 +957,7 @@ static VALUE libvirt_domain_max_memory_equal(VALUE d, VALUE max_memory)
  * call-seq:
  *   dom.memory = Fixnum,flags=0
  *
- * Call virDomainSetMemory[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetMemory]
+ * Call virDomainSetMemory[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetMemory]
  * to set the amount of memory (in kilobytes) this domain should currently
  * have.  Note this will only succeed if both the hypervisor and the domain on
  * this connection support ballooning.
@@ -1052,15 +969,14 @@ static VALUE libvirt_domain_memory_equal(VALUE d, VALUE in)
 
     domain_input_to_fixnum_and_flags(in, &memory, &flags);
 
-#if HAVE_VIRDOMAINSETMEMORYFLAGS
-    r = virDomainSetMemoryFlags(ruby_libvirt_domain_get(d), NUM2ULONG(memory),
-                                ruby_libvirt_value_to_uint(flags));
-#else
     if (ruby_libvirt_value_to_uint(flags) != 0) {
-        rb_raise(e_NoSupportError, "Non-zero flags not supported");
+        r = virDomainSetMemoryFlags(ruby_libvirt_domain_get(d),
+                                    NUM2ULONG(memory),
+                                    ruby_libvirt_value_to_uint(flags));
+    } else {
+        r = virDomainSetMemory(ruby_libvirt_domain_get(d),
+                               NUM2ULONG(memory));
     }
-    r = virDomainSetMemory(ruby_libvirt_domain_get(d), NUM2ULONG(memory));
-#endif
 
     ruby_libvirt_raise_error_if(r < 0, e_DefinitionError, "virDomainSetMemory",
                                 ruby_libvirt_connect_get(d));
@@ -1072,7 +988,7 @@ static VALUE libvirt_domain_memory_equal(VALUE d, VALUE in)
  * call-seq:
  *   dom.max_vcpus -> Fixnum
  *
- * Call virDomainGetMaxVcpus[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetMaxVcpus]
+ * Call virDomainGetMaxVcpus[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetMaxVcpus]
  * to retrieve the maximum number of virtual CPUs this domain can use.
  */
 static VALUE libvirt_domain_max_vcpus(VALUE d)
@@ -1082,11 +998,10 @@ static VALUE libvirt_domain_max_vcpus(VALUE d)
                                    ruby_libvirt_domain_get(d));
 }
 
-#if HAVE_VIRDOMAINGETVCPUSFLAGS
 /* call-seq:
  *   dom.num_vcpus(flags) -> Fixnum
  *
- * Call virDomainGetVcpusFlags[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetVcpusFlags]
+ * Call virDomainGetVcpusFlags[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetVcpusFlags]
  * to retrieve the number of virtual CPUs assigned to this domain.
  */
 static VALUE libvirt_domain_num_vcpus(VALUE d, VALUE flags)
@@ -1096,13 +1011,12 @@ static VALUE libvirt_domain_num_vcpus(VALUE d, VALUE flags)
                                    ruby_libvirt_domain_get(d),
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
 /*
  * call-seq:
  *   dom.vcpus = Fixnum,flags=0
  *
- * Call virDomainSetVcpus[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetVcpus]
+ * Call virDomainSetVcpus[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetVcpus]
  * to set the current number of virtual CPUs this domain should have.  Note
  * that this will only work if both the hypervisor and domain on this
  * connection support virtual CPU hotplug/hot-unplug.
@@ -1113,46 +1027,34 @@ static VALUE libvirt_domain_vcpus_equal(VALUE d, VALUE in)
 
     if (TYPE(in) == T_FIXNUM) {
         nvcpus = in;
-        flags = INT2NUM(0);
-    }
-#if HAVE_VIRDOMAINSETVCPUSFLAGS
-    else if (TYPE(in) == T_ARRAY) {
+        ruby_libvirt_generate_call_nil(virDomainSetVcpus,
+                                       ruby_libvirt_connect_get(d),
+                                       ruby_libvirt_domain_get(d),
+                                       NUM2UINT(nvcpus));
+    } else if (TYPE(in) == T_ARRAY) {
         if (RARRAY_LEN(in) != 2) {
             rb_raise(rb_eArgError, "wrong number of arguments (%ld for 2)",
                      RARRAY_LEN(in));
         }
         nvcpus = rb_ary_entry(in, 0);
         flags = rb_ary_entry(in, 1);
-    }
-    else {
+        ruby_libvirt_generate_call_nil(virDomainSetVcpusFlags,
+                                       ruby_libvirt_connect_get(d),
+                                       ruby_libvirt_domain_get(d),
+                                       NUM2UINT(nvcpus),
+                                       NUM2UINT(flags));
+    } else {
         rb_raise(rb_eTypeError,
                  "wrong argument type (expected Number or Array)");
     }
-
-    ruby_libvirt_generate_call_nil(virDomainSetVcpusFlags,
-                                   ruby_libvirt_connect_get(d),
-                                   ruby_libvirt_domain_get(d), NUM2UINT(nvcpus),
-                                   NUM2UINT(flags));
-#else
-
-    if (NUM2UINT(flags) != 0) {
-        rb_raise(e_NoSupportError, "Non-zero flags not supported");
-    }
-
-    ruby_libvirt_generate_call_nil(virDomainSetVcpus,
-                                   ruby_libvirt_connect_get(d),
-                                   ruby_libvirt_domain_get(d),
-                                   NUM2UINT(nvcpus));
-#endif
 }
 
-#if HAVE_VIRDOMAINSETVCPUSFLAGS
 /*
  * call-seq:
  *   dom.vcpus_flags = Fixnum,flags=0
  *
 
- * Call virDomainSetVcpusFlags[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetVcpusFlags]
+ * Call virDomainSetVcpusFlags[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetVcpusFlags]
  * to set the current number of virtual CPUs this domain should have.  The
  * flags parameter controls whether the change is made to the running domain
  * the domain configuration, or both, and must not be 0.  Deprecated;
@@ -1169,13 +1071,12 @@ static VALUE libvirt_domain_vcpus_flags_equal(VALUE d, VALUE in)
                                    ruby_libvirt_domain_get(d), NUM2UINT(nvcpus),
                                    NUM2UINT(flags));
 }
-#endif
 
 /*
  * call-seq:
  *   dom.pin_vcpu(vcpu, cpulist, flags=0) -> nil
  *
- * Call virDomainPinVcpu[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainPinVcpu]
+ * Call virDomainPinVcpu[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainPinVcpu]
  * to pin a particular virtual CPU to a range of physical processors.  The
  * cpulist should be an array of Fixnums representing the physical processors
  * this virtual CPU should be allowed to be scheduled on.
@@ -1202,29 +1103,28 @@ static VALUE libvirt_domain_pin_vcpu(int argc, VALUE *argv, VALUE d)
         VIR_USE_CPU(cpumap, NUM2UINT(e));
     }
 
-#if HAVE_VIRDOMAINPINVCPUFLAGS
-    ruby_libvirt_generate_call_nil(virDomainPinVcpuFlags,
-                                   ruby_libvirt_connect_get(d),
-                                   ruby_libvirt_domain_get(d),
-                                   NUM2UINT(vcpu), cpumap, cpumaplen,
-                                   ruby_libvirt_value_to_uint(flags));
-#else
     if (ruby_libvirt_value_to_uint(flags) != 0) {
-        rb_raise(e_NoSupportError, "Non-zero flags not supported");
+        ruby_libvirt_generate_call_nil(virDomainPinVcpuFlags,
+                                       ruby_libvirt_connect_get(d),
+                                       ruby_libvirt_domain_get(d),
+                                       NUM2UINT(vcpu),
+                                       cpumap,
+                                       cpumaplen,
+                                       ruby_libvirt_value_to_uint(flags));
+    } else {
+        ruby_libvirt_generate_call_nil(virDomainPinVcpu,
+                                       ruby_libvirt_connect_get(d),
+                                       ruby_libvirt_domain_get(d),
+                                       NUM2UINT(vcpu),
+                                       cpumap, cpumaplen);
     }
-
-    ruby_libvirt_generate_call_nil(virDomainPinVcpu,
-                                   ruby_libvirt_connect_get(d),
-                                   ruby_libvirt_domain_get(d), NUM2UINT(vcpu),
-                                   cpumap, cpumaplen);
-#endif
 }
 
 /*
  * call-seq:
  *   dom.xml_desc(flags=0) -> String
  *
- * Call virDomainGetXMLDesc[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetXMLDesc]
+ * Call virDomainGetXMLDesc[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetXMLDesc]
  * to retrieve the XML describing this domain.
  */
 static VALUE libvirt_domain_xml_desc(int argc, VALUE *argv, VALUE d)
@@ -1243,7 +1143,7 @@ static VALUE libvirt_domain_xml_desc(int argc, VALUE *argv, VALUE d)
  * call-seq:
  *   dom.undefine(flags=0) -> nil
  *
- * Call virDomainUndefine[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainUndefine]
+ * Call virDomainUndefine[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainUndefine]
  * to undefine the domain.  After this call, the domain object is no longer
  * valid.
  */
@@ -1253,27 +1153,23 @@ static VALUE libvirt_domain_undefine(int argc, VALUE *argv, VALUE d)
 
     rb_scan_args(argc, argv, "01", &flags);
 
-#if HAVE_VIRDOMAINUNDEFINEFLAGS
-    ruby_libvirt_generate_call_nil(virDomainUndefineFlags,
-                                   ruby_libvirt_connect_get(d),
-                                   ruby_libvirt_domain_get(d),
-                                   ruby_libvirt_value_to_uint(flags));
-#else
     if (ruby_libvirt_value_to_uint(flags) != 0) {
-        rb_raise(e_NoSupportError, "Non-zero flags not supported");
+        ruby_libvirt_generate_call_nil(virDomainUndefineFlags,
+                                       ruby_libvirt_connect_get(d),
+                                       ruby_libvirt_domain_get(d),
+                                       ruby_libvirt_value_to_uint(flags));
+    } else {
+        ruby_libvirt_generate_call_nil(virDomainUndefine,
+                                       ruby_libvirt_connect_get(d),
+                                       ruby_libvirt_domain_get(d));
     }
-
-    ruby_libvirt_generate_call_nil(virDomainUndefine,
-                                   ruby_libvirt_connect_get(d),
-                                   ruby_libvirt_domain_get(d));
-#endif
 }
 
 /*
  * call-seq:
  *   dom.create(flags=0) -> nil
  *
- * Call virDomainCreate[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainCreate]
+ * Call virDomainCreate[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainCreate]
  * to start an already defined domain.
  */
 static VALUE libvirt_domain_create(int argc, VALUE *argv, VALUE d)
@@ -1282,25 +1178,23 @@ static VALUE libvirt_domain_create(int argc, VALUE *argv, VALUE d)
 
     rb_scan_args(argc, argv, "01", &flags);
 
-#if HAVE_VIRDOMAINCREATEWITHFLAGS
-    ruby_libvirt_generate_call_nil(virDomainCreateWithFlags,
-                                   ruby_libvirt_connect_get(d),
-                                   ruby_libvirt_domain_get(d),
-                                   ruby_libvirt_value_to_uint(flags));
-#else
     if (ruby_libvirt_value_to_uint(flags) != 0) {
-        rb_raise(e_NoSupportError, "Non-zero flags not supported");
+        ruby_libvirt_generate_call_nil(virDomainCreateWithFlags,
+                                       ruby_libvirt_connect_get(d),
+                                       ruby_libvirt_domain_get(d),
+                                       ruby_libvirt_value_to_uint(flags));
+    } else {
+        ruby_libvirt_generate_call_nil(virDomainCreate,
+                                       ruby_libvirt_connect_get(d),
+                                       ruby_libvirt_domain_get(d));
     }
-    ruby_libvirt_generate_call_nil(virDomainCreate, ruby_libvirt_connect_get(d),
-                                   ruby_libvirt_domain_get(d));
-#endif
 }
 
 /*
  * call-seq:
  *   dom.autostart -> [true|false]
  *
- * Call virDomainGetAutostart[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetAutostart]
+ * Call virDomainGetAutostart[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetAutostart]
  * to find out the state of the autostart flag for a domain.
  */
 static VALUE libvirt_domain_autostart(VALUE d)
@@ -1318,7 +1212,7 @@ static VALUE libvirt_domain_autostart(VALUE d)
  * call-seq:
  *   dom.autostart = [true|false]
  *
- * Call virDomainSetAutostart[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetAutostart]
+ * Call virDomainSetAutostart[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetAutostart]
  * to make this domain autostart when libvirtd starts up.
  */
 static VALUE libvirt_domain_autostart_equal(VALUE d, VALUE autostart)
@@ -1338,7 +1232,7 @@ static VALUE libvirt_domain_autostart_equal(VALUE d, VALUE autostart)
  * call-seq:
  *   dom.attach_device(device_xml, flags=0) -> nil
  *
- * Call virDomainAttachDevice[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainAttachDevice]
+ * Call virDomainAttachDevice[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainAttachDevice]
  * to attach the device described by the device_xml to the domain.
  */
 static VALUE libvirt_domain_attach_device(int argc, VALUE *argv, VALUE d)
@@ -1347,28 +1241,25 @@ static VALUE libvirt_domain_attach_device(int argc, VALUE *argv, VALUE d)
 
     rb_scan_args(argc, argv, "11", &xml, &flags);
 
-#if HAVE_VIRDOMAINATTACHDEVICEFLAGS
-    ruby_libvirt_generate_call_nil(virDomainAttachDeviceFlags,
-                                   ruby_libvirt_connect_get(d),
-                                   ruby_libvirt_domain_get(d),
-                                   StringValueCStr(xml),
-                                   ruby_libvirt_value_to_uint(flags));
-#else
     if (ruby_libvirt_value_to_uint(flags) != 0) {
-        rb_raise(e_NoSupportError, "Non-zero flags not supported");
+        ruby_libvirt_generate_call_nil(virDomainAttachDeviceFlags,
+                                       ruby_libvirt_connect_get(d),
+                                       ruby_libvirt_domain_get(d),
+                                       StringValueCStr(xml),
+                                       ruby_libvirt_value_to_uint(flags));
+    } else {
+        ruby_libvirt_generate_call_nil(virDomainAttachDevice,
+                                       ruby_libvirt_connect_get(d),
+                                       ruby_libvirt_domain_get(d),
+                                       StringValueCStr(xml));
     }
-    ruby_libvirt_generate_call_nil(virDomainAttachDevice,
-                                   ruby_libvirt_connect_get(d),
-                                   ruby_libvirt_domain_get(d),
-                                   StringValueCStr(xml));
-#endif
 }
 
 /*
  * call-seq:
  *   dom.detach_device(device_xml, flags=0) -> nil
  *
- * Call virDomainDetachDevice[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainDetachDevice]
+ * Call virDomainDetachDevice[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainDetachDevice]
  * to detach the device described by the device_xml from the domain.
  */
 static VALUE libvirt_domain_detach_device(int argc, VALUE *argv, VALUE d)
@@ -1377,29 +1268,25 @@ static VALUE libvirt_domain_detach_device(int argc, VALUE *argv, VALUE d)
 
     rb_scan_args(argc, argv, "11", &xml, &flags);
 
-#if HAVE_VIRDOMAINDETACHDEVICEFLAGS
-    ruby_libvirt_generate_call_nil(virDomainDetachDeviceFlags,
-                                   ruby_libvirt_connect_get(d),
-                                   ruby_libvirt_domain_get(d),
-                                   StringValueCStr(xml),
-                                   ruby_libvirt_value_to_uint(flags));
-#else
     if (ruby_libvirt_value_to_uint(flags) != 0) {
-        rb_raise(e_NoSupportError, "Non-zero flags not supported");
+        ruby_libvirt_generate_call_nil(virDomainDetachDeviceFlags,
+                                       ruby_libvirt_connect_get(d),
+                                       ruby_libvirt_domain_get(d),
+                                       StringValueCStr(xml),
+                                       ruby_libvirt_value_to_uint(flags));
+    } else {
+        ruby_libvirt_generate_call_nil(virDomainDetachDevice,
+                                       ruby_libvirt_connect_get(d),
+                                       ruby_libvirt_domain_get(d),
+                                       StringValueCStr(xml));
     }
-    ruby_libvirt_generate_call_nil(virDomainDetachDevice,
-                                   ruby_libvirt_connect_get(d),
-                                   ruby_libvirt_domain_get(d),
-                                   StringValueCStr(xml));
-#endif
 }
 
-#if HAVE_VIRDOMAINUPDATEDEVICEFLAGS
 /*
  * call-seq:
  *   dom.update_device(device_xml, flags=0) -> nil
  *
- * Call virDomainUpdateDeviceFlags[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainUpdateDeviceFlags]
+ * Call virDomainUpdateDeviceFlags[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainUpdateDeviceFlags]
  * to update the device described by the device_xml.
  */
 static VALUE libvirt_domain_update_device(int argc, VALUE *argv, VALUE d)
@@ -1414,13 +1301,12 @@ static VALUE libvirt_domain_update_device(int argc, VALUE *argv, VALUE d)
                                    StringValueCStr(xml),
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
 /*
  * call-seq:
  *   dom.free -> nil
  *
- * Call virDomainFree[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainFree]
+ * Call virDomainFree[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainFree]
  * to free a domain object.
  */
 static VALUE libvirt_domain_free(VALUE d)
@@ -1428,7 +1314,6 @@ static VALUE libvirt_domain_free(VALUE d)
     ruby_libvirt_generate_call_free(Domain, d);
 }
 
-#if HAVE_TYPE_VIRDOMAINSNAPSHOTPTR
 static void domain_snapshot_free(void *d)
 {
     ruby_libvirt_free_struct(DomainSnapshot, d);
@@ -1455,7 +1340,7 @@ static virDomainSnapshotPtr domain_snapshot_get(VALUE d)
  * call-seq:
  *   dom.snapshot_create_xml(snapshot_xml, flags=0) -> Libvirt::Domain::Snapshot
  *
- * Call virDomainSnapshotCreateXML[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotCreateXML]
+ * Call virDomainSnapshotCreateXML[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotCreateXML]
  * to create a new snapshot based on snapshot_xml.
  */
 static VALUE libvirt_domain_snapshot_create_xml(int argc, VALUE *argv, VALUE d)
@@ -1480,7 +1365,7 @@ static VALUE libvirt_domain_snapshot_create_xml(int argc, VALUE *argv, VALUE d)
  * call-seq:
  *   dom.num_of_snapshots(flags=0) -> Fixnum
  *
- * Call virDomainSnapshotNum[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotNum]
+ * Call virDomainSnapshotNum[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotNum]
  * to retrieve the number of available snapshots for this domain.
  */
 static VALUE libvirt_domain_num_of_snapshots(int argc, VALUE *argv, VALUE d)
@@ -1499,7 +1384,7 @@ static VALUE libvirt_domain_num_of_snapshots(int argc, VALUE *argv, VALUE d)
  * call-seq:
  *   dom.list_snapshots(flags=0) -> list
  *
- * Call virDomainSnapshotListNames[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotListNames]
+ * Call virDomainSnapshotListNames[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotListNames]
  * to retrieve a list of snapshot names available for this domain.
  */
 static VALUE libvirt_domain_list_snapshots(int argc, VALUE *argv, VALUE d)
@@ -1539,7 +1424,7 @@ static VALUE libvirt_domain_list_snapshots(int argc, VALUE *argv, VALUE d)
  * call-seq:
  *   dom.lookup_snapshot_by_name(name, flags=0) -> Libvirt::Domain::Snapshot
  *
- * Call virDomainSnapshotLookupByName[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotLookupByName]
+ * Call virDomainSnapshotLookupByName[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotLookupByName]
  * to retrieve a snapshot object corresponding to snapshot name.
  */
 static VALUE libvirt_domain_lookup_snapshot_by_name(int argc, VALUE *argv,
@@ -1564,7 +1449,7 @@ static VALUE libvirt_domain_lookup_snapshot_by_name(int argc, VALUE *argv,
  * call-seq:
  *   dom.has_current_snapshot?(flags=0) -> [true|false]
  *
- * Call virDomainHasCurrentSnapshot[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainHasCurrentSnapshot]
+ * Call virDomainHasCurrentSnapshot[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainHasCurrentSnapshot]
  * to find out if this domain has a snapshot active.
  */
 static VALUE libvirt_domain_has_current_snapshot_p(int argc, VALUE *argv,
@@ -1584,7 +1469,7 @@ static VALUE libvirt_domain_has_current_snapshot_p(int argc, VALUE *argv,
  * call-seq:
  *   dom.revert_to_snapshot(snapshot_object, flags=0) -> nil
  *
- * Call virDomainRevertToSnapshot[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainRevertToSnapshot]
+ * Call virDomainRevertToSnapshot[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainRevertToSnapshot]
  * to restore this domain to a previously saved snapshot.
  */
 static VALUE libvirt_domain_revert_to_snapshot(int argc, VALUE *argv, VALUE d)
@@ -1603,7 +1488,7 @@ static VALUE libvirt_domain_revert_to_snapshot(int argc, VALUE *argv, VALUE d)
  * call-seq:
  *   dom.current_snapshot(flags=0) -> Libvirt::Domain::Snapshot
  *
- * Call virDomainCurrentSnapshot[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainCurrentSnapshot]
+ * Call virDomainCurrentSnapshot[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainCurrentSnapshot]
  * to retrieve the current snapshot for this domain (if any).
  */
 static VALUE libvirt_domain_current_snapshot(int argc, VALUE *argv, VALUE d)
@@ -1626,7 +1511,7 @@ static VALUE libvirt_domain_current_snapshot(int argc, VALUE *argv, VALUE d)
  * call-seq:
  *   snapshot.xml_desc(flags=0) -> String
  *
- * Call virDomainSnapshotGetXMLDesc[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotGetXMLDesc]
+ * Call virDomainSnapshotGetXMLDesc[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotGetXMLDesc]
  * to retrieve the xml description for this snapshot.
  */
 static VALUE libvirt_domain_snapshot_xml_desc(int argc, VALUE *argv, VALUE s)
@@ -1645,7 +1530,7 @@ static VALUE libvirt_domain_snapshot_xml_desc(int argc, VALUE *argv, VALUE s)
  * call-seq:
  *   snapshot.delete(flags=0) -> nil
  *
- * Call virDomainSnapshotDelete[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotDelete]
+ * Call virDomainSnapshotDelete[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotDelete]
  * to delete this snapshot.
  */
 static VALUE libvirt_domain_snapshot_delete(int argc, VALUE *argv, VALUE s)
@@ -1664,7 +1549,7 @@ static VALUE libvirt_domain_snapshot_delete(int argc, VALUE *argv, VALUE s)
  * call-seq:
  *   snapshot.free -> nil
  *
- * Call virDomainSnapshotFree[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotFree]
+ * Call virDomainSnapshotFree[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotFree]
  * to free up the snapshot object.  After this call the snapshot object is
  * no longer valid.
  */
@@ -1673,14 +1558,12 @@ static VALUE libvirt_domain_snapshot_free(VALUE s)
     ruby_libvirt_generate_call_free(DomainSnapshot, s);
 }
 
-#endif
 
-#if HAVE_VIRDOMAINSNAPSHOTGETNAME
 /*
  * call-seq:
  *   snapshot.name -> String
  *
- * Call virDomainSnapshotGetName[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotGetName]
+ * Call virDomainSnapshotGetName[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotGetName]
  * to get the name associated with a snapshot.
  */
 static VALUE libvirt_domain_snapshot_name(VALUE s)
@@ -1689,15 +1572,13 @@ static VALUE libvirt_domain_snapshot_name(VALUE s)
                                       ruby_libvirt_connect_get(s),
                                       0, domain_snapshot_get(s));
 }
-#endif
 
 
-#if HAVE_TYPE_VIRDOMAINJOBINFOPTR
 /*
  * call-seq:
  *   dom.job_info -> Libvirt::Domain::JobInfo
  *
- * Call virDomainGetJobInfo[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetJobInfo]
+ * Call virDomainGetJobInfo[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetJobInfo]
  * to retrieve the current state of the running domain job.
  */
 static VALUE libvirt_domain_job_info(VALUE d)
@@ -1731,7 +1612,7 @@ static VALUE libvirt_domain_job_info(VALUE d)
  * call-seq:
  *   dom.abort_job -> nil
  *
- * Call virDomainAbortJob[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainAbortJob]
+ * Call virDomainAbortJob[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainAbortJob]
  * to abort the currently running job on this domain.
  */
 static VALUE libvirt_domain_abort_job(VALUE d)
@@ -1741,7 +1622,6 @@ static VALUE libvirt_domain_abort_job(VALUE d)
                                    ruby_libvirt_domain_get(d));
 }
 
-#endif
 
 struct create_sched_type_args {
     char *type;
@@ -1766,7 +1646,7 @@ static VALUE create_sched_type_array(VALUE input)
  * call-seq:
  *   dom.scheduler_type -> [type, #params]
  *
- * Call virDomainGetSchedulerType[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetSchedulerType]
+ * Call virDomainGetSchedulerType[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetSchedulerType]
  * to retrieve the scheduler type used on this domain.
  */
 static VALUE libvirt_domain_scheduler_type(VALUE d)
@@ -1793,7 +1673,6 @@ static VALUE libvirt_domain_scheduler_type(VALUE d)
     return result;
 }
 
-#if HAVE_VIRDOMAINQEMUMONITORCOMMAND
 /*
  * call-seq:
  *   dom.qemu_monitor_command(cmd, flags=0) -> String
@@ -1841,14 +1720,12 @@ static VALUE libvirt_domain_qemu_monitor_command(int argc, VALUE *argv, VALUE d)
 
     return ret;
 }
-#endif
 
-#if HAVE_VIRDOMAINISUPDATED
 /*
  * call-seq:
  *   dom.updated? ->  [True|False]
  *
- * Call virDomainIsUpdated[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainIsUpdated]
+ * Call virDomainIsUpdated[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainIsUpdated]
  * to determine whether the definition for this domain has been updated.
  */
 static VALUE libvirt_domain_is_updated(VALUE d)
@@ -1857,7 +1734,6 @@ static VALUE libvirt_domain_is_updated(VALUE d)
                                          ruby_libvirt_connect_get(d),
                                          ruby_libvirt_domain_get(d));
 }
-#endif
 
 static const char *scheduler_nparams(VALUE d,
                                      unsigned int RUBY_LIBVIRT_UNUSED(flags),
@@ -1882,21 +1758,17 @@ static const char *scheduler_get(VALUE d, unsigned int flags, void *voidparams,
 {
     virTypedParameterPtr params = (virTypedParameterPtr)voidparams;
 
-#ifdef HAVE_TYPE_VIRTYPEDPARAMETERPTR
-    if (virDomainGetSchedulerParametersFlags(ruby_libvirt_domain_get(d), params,
-                                             nparams, flags) < 0) {
-        return "virDomainGetSchedulerParameters";
-    }
-#else
     if (flags != 0) {
-        rb_raise(e_NoSupportError, "Non-zero flags not supported");
-    }
-    if (virDomainGetSchedulerParameters(ruby_libvirt_domain_get(d),
-                                        (virSchedParameterPtr)params,
-                                        nparams) < 0) {
-        return "virDomainGetSchedulerParameters";
+        if (virDomainGetSchedulerParametersFlags(ruby_libvirt_domain_get(d), params,
+                                                 nparams, flags) < 0) {
+            return "virDomainGetSchedulerParameters";
+        }
+    } else {
+        if (virDomainGetSchedulerParameters(ruby_libvirt_domain_get(d),
+                                            params, nparams) < 0) {
+            return "virDomainGetSchedulerParameters";
+        }
     }
-#endif
 
     return NULL;
 }
@@ -1905,21 +1777,17 @@ static const char *scheduler_set(VALUE d, unsigned int flags,
                                  virTypedParameterPtr params, int nparams,
                                  void *RUBY_LIBVIRT_UNUSED(opaque))
 {
-#if HAVE_TYPE_VIRTYPEDPARAMETERPTR
-    if (virDomainSetSchedulerParametersFlags(ruby_libvirt_domain_get(d), params,
-                                             nparams, flags) < 0) {
-        return "virDomainSetSchedulerParameters";
-    }
-#else
     if (flags != 0) {
-        rb_raise(e_NoSupportError, "Non-zero flags not supported");
-    }
-    if (virDomainSetSchedulerParameters(ruby_libvirt_domain_get(d),
-                                        (virSchedParameterPtr)params,
-                                        nparams) < 0) {
-        return "virDomainSetSchedulerParameters";
+        if (virDomainSetSchedulerParametersFlags(ruby_libvirt_domain_get(d), params,
+                                                 nparams, flags) < 0) {
+            return "virDomainSetSchedulerParameters";
+        }
+    } else {
+        if (virDomainSetSchedulerParameters(ruby_libvirt_domain_get(d),
+                                            params, nparams) < 0) {
+            return "virDomainSetSchedulerParameters";
+        }
     }
-#endif
 
     return NULL;
 }
@@ -1928,7 +1796,7 @@ static const char *scheduler_set(VALUE d, unsigned int flags,
  * call-seq:
  *   dom.scheduler_parameters(flags=0) -> Hash
  *
- * Call virDomainGetSchedulerParameters[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetSchedulerParameters]
+ * Call virDomainGetSchedulerParameters[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetSchedulerParameters]
  * to retrieve all of the scheduler parameters for this domain.  The keys and
  * values in the hash that is returned are hypervisor specific.
  */
@@ -1948,12 +1816,8 @@ static struct ruby_libvirt_typed_param domain_scheduler_allowed[] = {
     {VIR_DOMAIN_SCHEDULER_CPU_SHARES, VIR_TYPED_PARAM_ULLONG},
     {VIR_DOMAIN_SCHEDULER_VCPU_PERIOD, VIR_TYPED_PARAM_ULLONG},
     {VIR_DOMAIN_SCHEDULER_VCPU_QUOTA, VIR_TYPED_PARAM_LLONG},
-#if HAVE_CONST_VIR_DOMAIN_SCHEDULER_EMULATOR_PERIOD
     {VIR_DOMAIN_SCHEDULER_EMULATOR_PERIOD, VIR_TYPED_PARAM_ULLONG},
-#endif
-#if HAVE_CONST_VIR_DOMAIN_SCHEDULER_EMULATOR_QUOTA
     {VIR_DOMAIN_SCHEDULER_EMULATOR_QUOTA, VIR_TYPED_PARAM_LLONG},
-#endif
     {VIR_DOMAIN_SCHEDULER_WEIGHT, VIR_TYPED_PARAM_UINT},
     {VIR_DOMAIN_SCHEDULER_CAP, VIR_TYPED_PARAM_UINT},
     {VIR_DOMAIN_SCHEDULER_RESERVATION, VIR_TYPED_PARAM_LLONG},
@@ -1965,7 +1829,7 @@ static struct ruby_libvirt_typed_param domain_scheduler_allowed[] = {
  * call-seq:
  *   dom.scheduler_parameters = Hash
  *
- * Call virDomainSetSchedulerParameters[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetSchedulerParameters]
+ * Call virDomainSetSchedulerParameters[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetSchedulerParameters]
  * to set the scheduler parameters for this domain.  The keys and values in
  * the input hash are hypervisor specific.  If an empty hash is given, no
  * changes are made (and no error is raised).
@@ -1982,7 +1846,6 @@ static VALUE libvirt_domain_scheduler_parameters_equal(VALUE d, VALUE input)
                                              scheduler_set);
 }
 
-#if HAVE_VIRDOMAINSETMEMORYPARAMETERS
 static const char *memory_nparams(VALUE d, unsigned int flags,
                                   void *RUBY_LIBVIRT_UNUSED(opaque),
                                   int *nparams)
@@ -2000,14 +1863,8 @@ static const char *memory_get(VALUE d, unsigned int flags, void *voidparams,
 {
     virTypedParameterPtr params = (virTypedParameterPtr)voidparams;
 
-#ifdef HAVE_TYPE_VIRTYPEDPARAMETERPTR
     if (virDomainGetMemoryParameters(ruby_libvirt_domain_get(d), params,
                                      nparams, flags) < 0) {
-#else
-    if (virDomainGetMemoryParameters(ruby_libvirt_domain_get(d),
-                                     (virMemoryParameterPtr)params, nparams,
-                                     flags) < 0) {
-#endif
         return "virDomainGetMemoryParameters";
     }
 
@@ -2018,14 +1875,8 @@ static const char *memory_set(VALUE d, unsigned int flags,
                               virTypedParameterPtr params, int nparams,
                               void *RUBY_LIBVIRT_UNUSED(opaque))
 {
-#ifdef HAVE_TYPE_VIRTYPEDPARAMETERPTR
     if (virDomainSetMemoryParameters(ruby_libvirt_domain_get(d), params,
                                      nparams, flags) < 0) {
-#else
-    if (virDomainSetMemoryParameters(ruby_libvirt_domain_get(d),
-                                     (virMemoryParameterPtr)params, nparams,
-                                     flags) < 0) {
-#endif
         return "virDomainSetMemoryParameters";
     }
 
@@ -2036,7 +1887,7 @@ static const char *memory_set(VALUE d, unsigned int flags,
  * call-seq:
  *   dom.memory_parameters(flags=0) -> Hash
  *
- * Call virDomainGetMemoryParameters[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetMemoryParameters]
+ * Call virDomainGetMemoryParameters[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetMemoryParameters]
  * to retrieve all of the memory parameters for this domain.  The keys and
  * values in the hash that is returned are hypervisor specific.
  */
@@ -2062,7 +1913,7 @@ static struct ruby_libvirt_typed_param domain_memory_allowed[] = {
  * call-seq:
  *   dom.memory_parameters = Hash,flags=0
  *
- * Call virDomainSetMemoryParameters[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetMemoryParameters]
+ * Call virDomainSetMemoryParameters[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetMemoryParameters]
  * to set the memory parameters for this domain.  The keys and values in
  * the input hash are hypervisor specific.
  */
@@ -2077,9 +1928,7 @@ static VALUE libvirt_domain_memory_parameters_equal(VALUE d, VALUE in)
                                              ARRAY_SIZE(domain_memory_allowed),
                                              memory_set);
 }
-#endif
 
-#if HAVE_VIRDOMAINSETBLKIOPARAMETERS
 static const char *blkio_nparams(VALUE d, unsigned int flags,
                                  void *RUBY_LIBVIRT_UNUSED(opaque),
                                  int *nparams)
@@ -2097,14 +1946,8 @@ static const char *blkio_get(VALUE d, unsigned int flags, void *voidparams,
 {
     virTypedParameterPtr params = (virTypedParameterPtr)voidparams;
 
-#ifdef HAVE_TYPE_VIRTYPEDPARAMETERPTR
     if (virDomainGetBlkioParameters(ruby_libvirt_domain_get(d), params, nparams,
                                     flags) < 0) {
-#else
-    if (virDomainGetBlkioParameters(ruby_libvirt_domain_get(d),
-                                    (virBlkioParameterPtr)params, nparams,
-                                    flags) < 0) {
-#endif
         return "virDomainGetBlkioParameters";
     }
 
@@ -2115,14 +1958,8 @@ static const char *blkio_set(VALUE d, unsigned int flags,
                              virTypedParameterPtr params, int nparams,
                              void *RUBY_LIBVIRT_UNUSED(opaque))
 {
-#ifdef HAVE_TYPE_VIRTYPEDPARAMETERPTR
     if (virDomainSetBlkioParameters(ruby_libvirt_domain_get(d), params, nparams,
                                     flags) < 0) {
-#else
-    if (virDomainSetBlkioParameters(ruby_libvirt_domain_get(d),
-                                    (virBlkioParameterPtr)params, nparams,
-                                    flags) < 0) {
-#endif
         return "virDomainSetBlkioParameters";
     }
 
@@ -2133,7 +1970,7 @@ static const char *blkio_set(VALUE d, unsigned int flags,
  * call-seq:
  *   dom.blkio_parameters(flags=0) -> Hash
  *
- * Call virDomainGetBlkioParameters[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetBlkioParameters]
+ * Call virDomainGetBlkioParameters[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetBlkioParameters]
  * to retrieve all of the blkio parameters for this domain.  The keys and
  * values in the hash that is returned are hypervisor specific.
  */
@@ -2157,7 +1994,7 @@ static struct ruby_libvirt_typed_param blkio_allowed[] = {
  * call-seq:
  *   dom.blkio_parameters = Hash,flags=0
  *
- * Call virDomainSetBlkioParameters[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetBlkioParameters]
+ * Call virDomainSetBlkioParameters[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetBlkioParameters]
  * to set the blkio parameters for this domain.  The keys and values in
  * the input hash are hypervisor specific.
  */
@@ -2172,14 +2009,12 @@ static VALUE libvirt_domain_blkio_parameters_equal(VALUE d, VALUE in)
                                              ARRAY_SIZE(blkio_allowed),
                                              blkio_set);
 }
-#endif
 
-#if HAVE_VIRDOMAINGETSTATE
 /*
  * call-seq:
  *   dom.state(flags=0) -> state, reason
  *
- * Call virDomainGetState[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetState]
+ * Call virDomainGetState[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetState]
  * to get the current state of the domain.
  */
 static VALUE libvirt_domain_state(int argc, VALUE *argv, VALUE d)
@@ -2201,14 +2036,12 @@ static VALUE libvirt_domain_state(int argc, VALUE *argv, VALUE d)
 
     return result;
 }
-#endif
 
-#if HAVE_VIRDOMAINOPENCONSOLE
 /*
  * call-seq:
  *   dom.open_console(device, stream, flags=0) -> nil
  *
- * Call virDomainOpenConsole[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainOpenConsole]
+ * Call virDomainOpenConsole[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainOpenConsole]
  * to open up a console to device over stream.
  */
 static VALUE libvirt_domain_open_console(int argc, VALUE *argv, VALUE d)
@@ -2224,14 +2057,12 @@ static VALUE libvirt_domain_open_console(int argc, VALUE *argv, VALUE d)
                                    StringValueCStr(dev),
                                    ruby_libvirt_stream_get(st), NUM2INT(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINSCREENSHOT
 /*
  * call-seq:
  *   dom.screenshot(stream, screen, flags=0) -> nil
  *
- * Call virDomainScreenshot[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainScreenshot]
+ * Call virDomainScreenshot[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainScreenshot]
  * to take a screenshot of the domain console as a stream.
  */
 static VALUE libvirt_domain_screenshot(int argc, VALUE *argv, VALUE d)
@@ -2247,14 +2078,12 @@ static VALUE libvirt_domain_screenshot(int argc, VALUE *argv, VALUE d)
                                       NUM2UINT(screen),
                                       ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAININJECTNMI
 /*
  * call-seq:
  *   dom.inject_nmi(flags=0) -> nil
  *
- * Call virDomainInjectNMI[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainInjectNMI]
+ * Call virDomainInjectNMI[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainInjectNMI]
  * to send an NMI to the guest.
  */
 static VALUE libvirt_domain_inject_nmi(int argc, VALUE *argv, VALUE d)
@@ -2268,14 +2097,12 @@ static VALUE libvirt_domain_inject_nmi(int argc, VALUE *argv, VALUE d)
                                    ruby_libvirt_domain_get(d),
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINGETCONTROLINFO
 /*
  * call-seq:
  *   dom.control_info(flags=0) -> Libvirt::Domain::ControlInfo
  *
- * Call virDomainGetControlInfo[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetControlInfo]
+ * Call virDomainGetControlInfo[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetControlInfo]
  * to retrieve domain control interface information.
  */
 static VALUE libvirt_domain_control_info(int argc, VALUE *argv, VALUE d)
@@ -2299,14 +2126,12 @@ static VALUE libvirt_domain_control_info(int argc, VALUE *argv, VALUE d)
 
     return result;
 }
-#endif
 
-#if HAVE_VIRDOMAINSENDKEY
 /*
  * call-seq:
  *   dom.send_key(codeset, holdtime, keycodes)
  *
- * Call virDomainSendKey[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSendKey]
+ * Call virDomainSendKey[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSendKey]
  * to send key(s) to the domain. Keycodes has to be an array of keys to send.
  */
 VALUE libvirt_domain_send_key(VALUE d, VALUE codeset, VALUE holdtime,
@@ -2329,14 +2154,12 @@ VALUE libvirt_domain_send_key(VALUE d, VALUE codeset, VALUE holdtime,
                                    NUM2UINT(codeset), NUM2UINT(holdtime), codes,
                                    RARRAY_LEN(keycodes), 0);
 }
-#endif
 
-#if HAVE_VIRDOMAINMIGRATEGETMAXSPEED
 /*
  * call-seq:
  *   dom.migrate_max_speed(flags=0) -> Fixnum
  *
- * Call virDomainMigrateGetMaxSpeed[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateGetMaxSpeed]
+ * Call virDomainMigrateGetMaxSpeed[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateGetMaxSpeed]
  * to retrieve the maximum speed a migration can use.
  */
 static VALUE libvirt_domain_migrate_max_speed(int argc, VALUE *argv, VALUE d)
@@ -2355,14 +2178,12 @@ static VALUE libvirt_domain_migrate_max_speed(int argc, VALUE *argv, VALUE d)
 
     return ULONG2NUM(bandwidth);
 }
-#endif
 
-#if HAVE_VIRDOMAINRESET
 /*
  * call-seq:
  *   dom.reset(flags=0) -> nil
  *
- * Call virDomainReset[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainReset]
+ * Call virDomainReset[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainReset]
  * to reset a domain immediately.
  */
 static VALUE libvirt_domain_reset(int argc, VALUE *argv, VALUE d)
@@ -2375,14 +2196,12 @@ static VALUE libvirt_domain_reset(int argc, VALUE *argv, VALUE d)
                                    ruby_libvirt_domain_get(d),
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINGETHOSTNAME
 /*
  * call-seq:
  *   dom.hostname(flags=0) -> nil
  *
- * Call virDomainGetHostname[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetHostname]
+ * Call virDomainGetHostname[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetHostname]
  * to get the hostname from a domain.
  */
 static VALUE libvirt_domain_hostname(int argc, VALUE *argv, VALUE d)
@@ -2396,14 +2215,12 @@ static VALUE libvirt_domain_hostname(int argc, VALUE *argv, VALUE d)
                                       ruby_libvirt_domain_get(d),
                                       ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINGETMETADATA
 /*
  * call-seq:
  *   dom.metadata(type, uri=nil, flags=0) -> String
  *
- * Call virDomainGetMetadata[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetMetadata]
+ * Call virDomainGetMetadata[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetMetadata]
  * to get the metadata from a domain.
  */
 static VALUE libvirt_domain_metadata(int argc, VALUE *argv, VALUE d)
@@ -2418,14 +2235,12 @@ static VALUE libvirt_domain_metadata(int argc, VALUE *argv, VALUE d)
                                       ruby_libvirt_get_cstring_or_null(uri),
                                       ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINSETMETADATA
 /*
  * call-seq:
  *   dom.metadata = Fixnum,string/nil,key=nil,uri=nil,flags=0 -> nil
  *
- * Call virDomainSetMetadata[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetMetadata]
+ * Call virDomainSetMetadata[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetMetadata]
  * to set the metadata for a domain.
  */
 static VALUE libvirt_domain_metadata_equal(VALUE d, VALUE in)
@@ -2464,14 +2279,12 @@ static VALUE libvirt_domain_metadata_equal(VALUE d, VALUE in)
                                    ruby_libvirt_get_cstring_or_null(uri),
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINSENDPROCESSSIGNAL
 /*
  * call-seq:
  *   dom.send_process_signal(pid, signum, flags=0) -> nil
  *
- * Call virDomainSendProcessSignal[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSendProcessSignal]
+ * Call virDomainSendProcessSignal[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSendProcessSignal]
  * to send a signal to a process inside the domain.
  */
 static VALUE libvirt_domain_send_process_signal(int argc, VALUE *argv, VALUE d)
@@ -2486,14 +2299,12 @@ static VALUE libvirt_domain_send_process_signal(int argc, VALUE *argv, VALUE d)
                                    NUM2UINT(signum),
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINLISTALLSNAPSHOTS
 /*
  * call-seq:
  *   dom.list_all_snapshots(flags=0) -> Array
  *
- * Call virDomainListAllSnapshots[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainListAllSnapshots]
+ * Call virDomainListAllSnapshots[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainListAllSnapshots]
  * to get an array of snapshot objects for all snapshots.
  */
 static VALUE libvirt_domain_list_all_snapshots(int argc, VALUE *argv, VALUE d)
@@ -2504,14 +2315,12 @@ static VALUE libvirt_domain_list_all_snapshots(int argc, VALUE *argv, VALUE d)
                                         domain_snapshot_new,
                                         virDomainSnapshotFree);
 }
-#endif
 
-#if HAVE_VIRDOMAINSNAPSHOTNUMCHILDREN
 /*
  * call-seq:
  *   snapshot.num_children(flags=0) -> Fixnum
  *
- * Call virDomainSnapshotNumChildren[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotNumChildren]
+ * Call virDomainSnapshotNumChildren[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotNumChildren]
  * to get the number of children snapshots of this snapshot.
  */
 static VALUE libvirt_domain_snapshot_num_children(int argc, VALUE *argv,
@@ -2526,14 +2335,12 @@ static VALUE libvirt_domain_snapshot_num_children(int argc, VALUE *argv,
                                    domain_snapshot_get(s),
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINSNAPSHOTLISTCHILDRENNAMES
 /*
  * call-seq:
  *   snapshot.list_children_names(flags=0) -> Array
  *
- * Call virDomainSnapshotListChildrenNames[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotListChildrenNames]
+ * Call virDomainSnapshotListChildrenNames[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotListChildrenNames]
  * to get an array of strings representing the children of this snapshot.
  */
 static VALUE libvirt_domain_snapshot_list_children_names(int argc, VALUE *argv,
@@ -2590,14 +2397,12 @@ error:
     /* not necessary, just to shut the compiler up */
     return Qnil;
 }
-#endif
 
-#if HAVE_VIRDOMAINSNAPSHOTLISTALLCHILDREN
 /*
  * call-seq:
  *   snapshot.list_all_children(flags=0) -> Array
  *
- * Call virDomainSnapshotListAllChildren[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotListAllChildren]
+ * Call virDomainSnapshotListAllChildren[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotListAllChildren]
  * to get an array of snapshot objects that are children of this snapshot.
  */
 static VALUE libvirt_domain_snapshot_list_all_children(int argc, VALUE *argv,
@@ -2609,14 +2414,12 @@ static VALUE libvirt_domain_snapshot_list_all_children(int argc, VALUE *argv,
                                         domain_snapshot_new,
                                         virDomainSnapshotFree);
 }
-#endif
 
-#if HAVE_VIRDOMAINSNAPSHOTGETPARENT
 /*
  * call-seq:
  *   snapshot.parent(flags=0) -> [Libvirt::Domain::Snapshot|nil]
  *
- * Call virDomainSnapshotGetParent[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotGetParent]
+ * Call virDomainSnapshotGetParent[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotGetParent]
  * to get the parent of this snapshot (nil will be returned if this is a root
  * snapshot).
  */
@@ -2646,14 +2449,12 @@ static VALUE libvirt_domain_snapshot_parent(int argc, VALUE *argv, VALUE s)
 
     return domain_snapshot_new(snap, s);
 }
-#endif
 
-#if HAVE_VIRDOMAINSNAPSHOTISCURRENT
 /*
  * call-seq:
  *   snapshot.current?(flags=0) -> [true|false]
  *
- * Call virDomainSnapshotIsCurrent[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotIsCurrent]
+ * Call virDomainSnapshotIsCurrent[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotIsCurrent]
  * to determine if the snapshot is the domain's current snapshot.
  */
 static VALUE libvirt_domain_snapshot_current_p(int argc, VALUE *argv, VALUE s)
@@ -2667,14 +2468,12 @@ static VALUE libvirt_domain_snapshot_current_p(int argc, VALUE *argv, VALUE s)
                                          domain_snapshot_get(s),
                                          ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINSNAPSHOTHASMETADATA
 /*
  * call-seq:
  *   snapshot.has_metadata?(flags=0) -> [true|false]
  *
- * Call virDomainSnapshotHasMetadata[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotHasMetadata]
+ * Call virDomainSnapshotHasMetadata[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSnapshotHasMetadata]
  * to determine if the snapshot is associated with libvirt metadata.
  */
 static VALUE libvirt_domain_snapshot_has_metadata_p(int argc, VALUE *argv,
@@ -2689,14 +2488,12 @@ static VALUE libvirt_domain_snapshot_has_metadata_p(int argc, VALUE *argv,
                                          domain_snapshot_get(s),
                                          ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINSETMEMORYSTATSPERIOD
 /*
  * call-seq:
  *   dom.memory_stats_period = Fixnum,flags=0
  *
- * Call virDomainSetMemoryStatsPeriod[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetMemoryStatsPeriod]
+ * Call virDomainSetMemoryStatsPeriod[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetMemoryStatsPeriod]
  * to set the memory statistics collection period.
  */
 static VALUE libvirt_domain_memory_stats_period(VALUE d, VALUE in)
@@ -2711,14 +2508,12 @@ static VALUE libvirt_domain_memory_stats_period(VALUE d, VALUE in)
                                    NUM2INT(period),
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINFSTRIM
 /*
  * call-seq:
  *   dom.fstrim(mountpoint=nil, minimum=0, flags=0) -> nil
  *
- * Call virDomainFSTrim[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainFSTrim]
+ * Call virDomainFSTrim[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainFSTrim]
  * to call FITRIM within the guest.
  */
 static VALUE libvirt_domain_fstrim(int argc, VALUE *argv, VALUE d)
@@ -2733,14 +2528,12 @@ static VALUE libvirt_domain_fstrim(int argc, VALUE *argv, VALUE d)
                                    ruby_libvirt_value_to_ulonglong(minimum),
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINBLOCKREBASE
 /*
  * call-seq:
  *   dom.block_rebase(disk, base=nil, bandwidth=0, flags=0) -> nil
  *
- * Call virDomainBlockRebase[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockRebase]
+ * Call virDomainBlockRebase[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockRebase]
  * to populate a disk image with data from its backing image chain.
  */
 static VALUE libvirt_domain_block_rebase(int argc, VALUE *argv, VALUE d)
@@ -2757,14 +2550,12 @@ static VALUE libvirt_domain_block_rebase(int argc, VALUE *argv, VALUE d)
                                    ruby_libvirt_value_to_ulong(bandwidth),
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINOPENCHANNEL
 /*
  * call-seq:
  *   dom.open_channel(name, stream, flags=0) -> nil
  *
- * Call virDomainOpenChannel[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainOpenChannel]
+ * Call virDomainOpenChannel[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainOpenChannel]
  * to open a channel on a guest.  Note that name may be nil, in which case the
  * first channel on the guest is opened.
  */
@@ -2781,14 +2572,12 @@ static VALUE libvirt_domain_open_channel(int argc, VALUE *argv, VALUE d)
                                    ruby_libvirt_stream_get(st),
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINCREATEWITHFILES
 /*
  * call-seq:
  *   dom.create_with_files(fds=nil, flags=0) -> nil
  *
- * Call virDomainCreateWithFiles[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainCreateWithFiles]
+ * Call virDomainCreateWithFiles[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainCreateWithFiles]
  * to launch a defined domain with a set of open file descriptors.
  */
 static VALUE libvirt_domain_create_with_files(int argc, VALUE *argv, VALUE d)
@@ -2820,14 +2609,12 @@ static VALUE libvirt_domain_create_with_files(int argc, VALUE *argv, VALUE d)
                                    numfiles, files,
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINOPENGRAPHICS
 /*
  * call-seq:
  *   dom.open_graphics(fd, idx=0, flags=0) -> nil
  *
- * Call virDomainOpenGraphics[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainOpenGraphics]
+ * Call virDomainOpenGraphics[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainOpenGraphics]
  * to connect a file descriptor to the graphics backend of the domain.
  */
 static VALUE libvirt_domain_open_graphics(int argc, VALUE *argv, VALUE d)
@@ -2842,14 +2629,12 @@ static VALUE libvirt_domain_open_graphics(int argc, VALUE *argv, VALUE d)
                                    ruby_libvirt_value_to_uint(idx), NUM2INT(fd),
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINPMWAKEUP
 /*
  * call-seq:
  *   dom.pmwakeup(flags=0) -> nil
  *
- * Call virDomainPMWakeup[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainPMWakeup]
+ * Call virDomainPMWakeup[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainPMWakeup]
  * to inject a wakeup into the guest.
  */
 static VALUE libvirt_domain_pmwakeup(int argc, VALUE *argv, VALUE d)
@@ -2863,14 +2648,12 @@ static VALUE libvirt_domain_pmwakeup(int argc, VALUE *argv, VALUE d)
                                    ruby_libvirt_domain_get(d),
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINBLOCKRESIZE
 /*
  * call-seq:
  *   dom.block_resize(disk, size, flags=0) -> nil
  *
- * Call virDomainBlockResize[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockResize]
+ * Call virDomainBlockResize[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockResize]
  * to resize a block device of domain.
  */
 static VALUE libvirt_domain_block_resize(int argc, VALUE *argv, VALUE d)
@@ -2885,14 +2668,12 @@ static VALUE libvirt_domain_block_resize(int argc, VALUE *argv, VALUE d)
                                    StringValueCStr(disk), NUM2ULL(size),
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINPMSUSPENDFORDURATION
 /*
  * call-seq:
  *   dom.pmsuspend_for_duration(target, duration, flags=0) -> nil
  *
- * Call virDomainPMSuspendForDuration[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainPMSuspendForDuration]
+ * Call virDomainPMSuspendForDuration[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainPMSuspendForDuration]
  * to have the domain enter the target power management suspend level.
  */
 static VALUE libvirt_domain_pmsuspend_for_duration(int argc, VALUE *argv,
@@ -2908,14 +2689,12 @@ static VALUE libvirt_domain_pmsuspend_for_duration(int argc, VALUE *argv,
                                    NUM2UINT(target), NUM2ULL(duration),
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINMIGRATEGETCOMPRESSIONCACHE
 /*
  * call-seq:
  *   dom.migrate_compression_cache(flags=0) -> Fixnum
  *
- * Call virDomainMigrateGetCompressionCache[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateGetCompressionCache]
+ * Call virDomainMigrateGetCompressionCache[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateGetCompressionCache]
  * to get the current size of the migration cache.
  */
 static VALUE libvirt_domain_migrate_compression_cache(int argc, VALUE *argv,
@@ -2936,14 +2715,12 @@ static VALUE libvirt_domain_migrate_compression_cache(int argc, VALUE *argv,
 
     return ULL2NUM(cachesize);
 }
-#endif
 
-#if HAVE_VIRDOMAINMIGRATESETCOMPRESSIONCACHE
 /*
  * call-seq:
  *   dom.migrate_compression_cache = Fixnum,flags=0
  *
- * Call virDomainMigrateSetCompressionCache[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateSetCompressionCache]
+ * Call virDomainMigrateSetCompressionCache[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateSetCompressionCache]
  * to set the current size of the migration cache.
  */
 static VALUE libvirt_domain_migrate_compression_cache_equal(VALUE d, VALUE in)
@@ -2958,14 +2735,12 @@ static VALUE libvirt_domain_migrate_compression_cache_equal(VALUE d, VALUE in)
                                    NUM2ULL(cachesize),
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINGETDISKERRORS
 /*
  * call-seq:
  *   dom.disk_errors(flags=0) -> Hash
  *
- * Call virDomainGetDiskErrors[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetDiskErrors]
+ * Call virDomainGetDiskErrors[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetDiskErrors]
  * to get errors on disks in the domain.
  */
 static VALUE libvirt_domain_disk_errors(int argc, VALUE *argv, VALUE d)
@@ -2999,14 +2774,12 @@ static VALUE libvirt_domain_disk_errors(int argc, VALUE *argv, VALUE d)
 
     return hash;
 }
-#endif
 
-#if HAVE_VIRDOMAINGETEMULATORPININFO
 /*
  * call-seq:
  *   dom.emulator_pin_info(flags=0) -> Array
  *
- * Call virDomainGetEmulatorPinInfo[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetEmulatorPinInfo]
+ * Call virDomainGetEmulatorPinInfo[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetEmulatorPinInfo]
  * to an array representing the mapping of emulator threads to physical CPUs.
  * For each physical CPU in the machine, the array offset corresponding to that
  * CPU is 'true' if an emulator thread is running on that CPU, and 'false'
@@ -3043,14 +2816,12 @@ static VALUE libvirt_domain_emulator_pin_info(int argc, VALUE *argv, VALUE d)
 
     return emulator2cpumap;
 }
-#endif
 
-#if HAVE_VIRDOMAINPINEMULATOR
 /*
  * call-seq:
  *   dom.pin_emulator(cpulist, flags=0) -> nil
  *
- * Call virDomainPinVcpu[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainPinVcpu]
+ * Call virDomainPinVcpu[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainPinVcpu]
  * to pin the emulator to a range of physical processors.  The cpulist should
  * be an array of Fixnums representing the physical processors this domain's
  * emulator should be allowed to be scheduled on.
@@ -3083,14 +2854,12 @@ static VALUE libvirt_domain_pin_emulator(int argc, VALUE *argv, VALUE d)
                                    cpumaplen,
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINGETSECURITYLABELLIST
 /*
  * call-seq:
  *   dom.security_label_list -> [ Libvirt::Domain::SecurityLabel ]
  *
- * Call virDomainGetSecurityLabelList[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetSecurityLabelList]
+ * Call virDomainGetSecurityLabelList[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetSecurityLabelList]
  * to retrieve the security labels applied to this domain.
  */
 static VALUE libvirt_domain_security_label_list(VALUE d)
@@ -3116,9 +2885,7 @@ static VALUE libvirt_domain_security_label_list(VALUE d)
 
     return result;
 }
-#endif
 
-#if HAVE_VIRDOMAINGETJOBSTATS
 struct params_to_hash_arg {
     virTypedParameterPtr params;
     int nparams;
@@ -3141,7 +2908,7 @@ static VALUE params_to_hash(VALUE in)
  * call-seq:
  *   dom.job_stats -> Hash
  *
- * Call virDomainGetJobStats[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetJobStats]
+ * Call virDomainGetJobStats[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetJobStats]
  * to retrieve information about progress of a background job on a domain.
  */
 static VALUE libvirt_domain_job_stats(int argc, VALUE *argv, VALUE d)
@@ -3187,9 +2954,7 @@ static VALUE libvirt_domain_job_stats(int argc, VALUE *argv, VALUE d)
 
     return result;
 }
-#endif
 
-#if HAVE_VIRDOMAINGETBLOCKIOTUNE
 static const char *iotune_nparams(VALUE d, unsigned int flags, void *opaque,
                                   int *nparams)
 {
@@ -3237,7 +3002,7 @@ static const char *iotune_set(VALUE d, unsigned int flags,
  * call-seq:
  *   dom.block_iotune(disk=nil, flags=0) -> Hash
  *
- * Call virDomainGetBlockIoTune[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetBlockIoTune]
+ * Call virDomainGetBlockIoTune[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetBlockIoTune]
  * to retrieve all of the block IO tune parameters for this domain.  The keys
  * and values in the hash that is returned are hypervisor specific.
  */
@@ -3252,9 +3017,7 @@ static VALUE libvirt_domain_block_iotune(int argc, VALUE *argv, VALUE d)
                                              (void *)disk, iotune_nparams,
                                              iotune_get);
 }
-#endif
 
-#if HAVE_VIRDOMAINSETBLOCKIOTUNE
 static struct ruby_libvirt_typed_param iotune_allowed[] = {
     {VIR_DOMAIN_BLOCK_IOTUNE_TOTAL_BYTES_SEC, VIR_TYPED_PARAM_ULLONG},
     {VIR_DOMAIN_BLOCK_IOTUNE_READ_BYTES_SEC, VIR_TYPED_PARAM_ULLONG},
@@ -3262,16 +3025,14 @@ static struct ruby_libvirt_typed_param iotune_allowed[] = {
     {VIR_DOMAIN_BLOCK_IOTUNE_TOTAL_IOPS_SEC, VIR_TYPED_PARAM_ULLONG},
     {VIR_DOMAIN_BLOCK_IOTUNE_READ_IOPS_SEC, VIR_TYPED_PARAM_ULLONG},
     {VIR_DOMAIN_BLOCK_IOTUNE_WRITE_IOPS_SEC, VIR_TYPED_PARAM_ULLONG},
-#if HAVE_CONST_VIR_DOMAIN_BLOCK_IOTUNE_SIZE_IOPS_SEC
     {VIR_DOMAIN_BLOCK_IOTUNE_SIZE_IOPS_SEC, VIR_TYPED_PARAM_ULLONG},
-#endif
 };
 
 /*
  * call-seq:
  *   dom.block_iotune = disk,Hash,flags=0
  *
- * Call virDomainSetBlockIoTune[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetBlockIoTune]
+ * Call virDomainSetBlockIoTune[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetBlockIoTune]
  * to set the block IO tune parameters for the supplied disk on this domain.
  * The keys and values in the input hash are hypervisor specific.
  */
@@ -3301,14 +3062,12 @@ static VALUE libvirt_domain_block_iotune_equal(VALUE d, VALUE in)
                                              ARRAY_SIZE(iotune_allowed),
                                              iotune_set);
 }
-#endif
 
-#if HAVE_VIRDOMAINBLOCKCOMMIT
 /*
  * call-seq:
  *   dom.block_commit(disk, base=nil, top=nil, bandwidth=0, flags=0) -> nil
  *
- * Call virDomainBlockCommit[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockCommit]
+ * Call virDomainBlockCommit[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockCommit]
  * to commit changes from a top-level backing file into a lower level base file.
  */
 static VALUE libvirt_domain_block_commit(int argc, VALUE *argv, VALUE d)
@@ -3326,14 +3085,12 @@ static VALUE libvirt_domain_block_commit(int argc, VALUE *argv, VALUE d)
                                    ruby_libvirt_value_to_ulong(bandwidth),
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINBLOCKPULL
 /*
  * call-seq:
  *   dom.block_pull(disk, bandwidth=0, flags=0) -> nil
  *
- * Call virDomainBlockPull[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockPull]
+ * Call virDomainBlockPull[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockPull]
  * to pull changes from a backing file into a disk image.
  */
 static VALUE libvirt_domain_block_pull(int argc, VALUE *argv, VALUE d)
@@ -3349,14 +3106,12 @@ static VALUE libvirt_domain_block_pull(int argc, VALUE *argv, VALUE d)
                                    ruby_libvirt_value_to_ulong(bandwidth),
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINBLOCKJOBSETSPEED
 /*
  * call-seq:
  *   dom.block_job_speed = disk,bandwidth=0,flags=0
  *
- * Call virDomainBlockJobSetSpeed[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockJobSetSpeed]
+ * Call virDomainBlockJobSetSpeed[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockJobSetSpeed]
  * to set the maximum allowable bandwidth a block job may consume.
  */
 static VALUE libvirt_domain_block_job_speed_equal(VALUE d, VALUE in)
@@ -3395,14 +3150,12 @@ static VALUE libvirt_domain_block_job_speed_equal(VALUE d, VALUE in)
                                    StringValueCStr(disk),
                                    NUM2UINT(bandwidth), NUM2UINT(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINGETBLOCKJOBINFO
 /*
  * call-seq:
  *   dom.block_job_info(disk, flags=0) -> Libvirt::Domain::BlockJobInfo
  *
- * Call virDomainGetBlockJobInfo[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetBlockJobInfo]
+ * Call virDomainGetBlockJobInfo[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetBlockJobInfo]
  * to get block job information for a given disk.
  */
 static VALUE libvirt_domain_block_job_info(int argc, VALUE *argv, VALUE d)
@@ -3430,14 +3183,12 @@ static VALUE libvirt_domain_block_job_info(int argc, VALUE *argv, VALUE d)
 
     return result;
 }
-#endif
 
-#if HAVE_VIRDOMAINBLOCKJOBABORT
 /*
  * call-seq:
  *   dom.block_job_abort(disk, flags=0) -> nil
  *
- * Call virDomainBlockJobAbort[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockJobAbort]
+ * Call virDomainBlockJobAbort[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainBlockJobAbort]
  * to cancel an active block job on the given disk.
  */
 static VALUE libvirt_domain_block_job_abort(int argc, VALUE *argv, VALUE d)
@@ -3452,9 +3203,7 @@ static VALUE libvirt_domain_block_job_abort(int argc, VALUE *argv, VALUE d)
                                    StringValueCStr(disk),
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINGETINTERFACEPARAMETERS
 static const char *interface_nparams(VALUE d, unsigned int flags, void *opaque,
                                      int *nparams)
 {
@@ -3502,7 +3251,7 @@ static const char *interface_set(VALUE d, unsigned int flags,
  * call-seq:
  *   dom.interface_parameters(interface, flags=0) -> Hash
  *
- * Call virDomainGetInterfaceParameters[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetInterfaceParameters]
+ * Call virDomainGetInterfaceParameters[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetInterfaceParameters]
  * to retrieve the interface parameters for the given interface on this domain.
  * The keys and values in the hash that is returned are hypervisor specific.
  */
@@ -3533,7 +3282,7 @@ static struct ruby_libvirt_typed_param interface_allowed[] = {
  * call-seq:
  *   dom.interface_parameters = device,Hash,flags=0
  *
- * Call virDomainSetInterfaceParameters[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetInterfaceParameters]
+ * Call virDomainSetInterfaceParameters[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetInterfaceParameters]
  * to set the interface parameters for the supplied device on this domain.
  * The keys and values in the input hash are hypervisor specific.
  */
@@ -3564,9 +3313,7 @@ static VALUE libvirt_domain_interface_parameters_equal(VALUE d, VALUE in)
                                              ARRAY_SIZE(interface_allowed),
                                              interface_set);
 }
-#endif
 
-#if HAVE_VIRDOMAINBLOCKSTATSFLAGS
 static const char *block_stats_nparams(VALUE d, unsigned int flags,
                                        void *opaque, int *nparams)
 {
@@ -3599,7 +3346,7 @@ static const char *block_stats_get(VALUE d, unsigned int flags,
  * call-seq:
  *   dom.block_stats_flags(disk, flags=0) -> Hash
  *
- * Call virDomainGetBlockStatsFlags[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetBlockStatsFlags]
+ * Call virDomainGetBlockStatsFlags[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetBlockStatsFlags]
  * to retrieve the block statistics for the given disk on this domain.
  * The keys and values in the hash that is returned are hypervisor specific.
  */
@@ -3617,9 +3364,7 @@ static VALUE libvirt_domain_block_stats_flags(int argc, VALUE *argv, VALUE d)
                                              block_stats_nparams,
                                              block_stats_get);
 }
-#endif
 
-#if HAVE_VIRDOMAINGETNUMAPARAMETERS
 static const char *numa_nparams(VALUE d, unsigned int flags,
                                 void *RUBY_LIBVIRT_UNUSED(opaque),
                                 int *nparams)
@@ -3660,7 +3405,7 @@ static const char *numa_set(VALUE d, unsigned int flags,
  * call-seq:
  *   dom.numa_parameters(flags=0) -> Hash
  *
- * Call virDomainGetNumaParameters[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetNumaParameters]
+ * Call virDomainGetNumaParameters[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetNumaParameters]
  * to retrieve the numa parameters for this domain.  The keys and values in
  * the hash that is returned are hypervisor specific.
  */
@@ -3684,7 +3429,7 @@ static struct ruby_libvirt_typed_param numa_allowed[] = {
  * call-seq:
  *   dom.numa_parameters = Hash,flags=0
  *
- * Call virDomainSetNumaParameters[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetNumaParameters]
+ * Call virDomainSetNumaParameters[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetNumaParameters]
  * to set the numa parameters for this domain.  The keys and values in the input
  * hash are hypervisor specific.
  */
@@ -3700,14 +3445,12 @@ static VALUE libvirt_domain_numa_parameters_equal(VALUE d, VALUE in)
                                              ARRAY_SIZE(numa_allowed),
                                              numa_set);
 }
-#endif
 
-#if HAVE_VIRDOMAINLXCOPENNAMESPACE
 /*
  * call-seq:
  *   dom.lxc_open_namespace(flags=0) -> Array
  *
- * Call virDomainLxcOpenNamespace[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainLxcOpenNamespace]
+ * Call virDomainLxcOpenNamespace[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainLxcOpenNamespace]
  * to open an LXC namespace.  Note that this will only work on connections to
  * the LXC driver.  The call will return an array of open file descriptors;
  * these should be closed when use of them is finished.
@@ -3757,14 +3500,12 @@ error:
     free(fdlist);
     rb_jump_tag(exception);
 }
-#endif
 
-#if HAVE_VIRDOMAINQEMUAGENTCOMMAND
 /*
  * call-seq:
  *   dom.qemu_agent_command(command, timeout=0, flags=0) -> String
  *
- * Call virDomainQemuAgentCommand[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainQemuAgentCommand]
+ * Call virDomainQemuAgentCommand[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainQemuAgentCommand]
  * to run an arbitrary command on the Qemu Agent.
  */
 static VALUE libvirt_domain_qemu_agent_command(int argc, VALUE *argv, VALUE d)
@@ -3775,6 +3516,10 @@ static VALUE libvirt_domain_qemu_agent_command(int argc, VALUE *argv, VALUE d)
 
     rb_scan_args(argc, argv, "12", &command, &timeout, &flags);
 
+    if (NIL_P(timeout)) {
+        timeout = INT2NUM(VIR_DOMAIN_QEMU_AGENT_COMMAND_DEFAULT);
+    }
+
     ret = virDomainQemuAgentCommand(ruby_libvirt_domain_get(d),
                                     StringValueCStr(command),
                                     ruby_libvirt_value_to_int(timeout),
@@ -3791,14 +3536,12 @@ static VALUE libvirt_domain_qemu_agent_command(int argc, VALUE *argv, VALUE d)
 
     return result;
 }
-#endif
 
-#if HAVE_VIRDOMAINLXCENTERNAMESPACE
 /*
  * call-seq:
  *   dom.lxc_enter_namespace(fds, flags=0) -> Array
  *
- * Call virDomainLxcEnterNamespace[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainLxcEnterNamespace]
+ * Call virDomainLxcEnterNamespace[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainLxcEnterNamespace]
  * to attach the process to the namespaces associated with the file descriptors
  * in the fds array.  Note that this call does not actually enter the namespace;
  * the next call to fork will do that.  Also note that this function will return
@@ -3857,25 +3600,21 @@ static VALUE libvirt_domain_lxc_enter_namespace(int argc, VALUE *argv, VALUE d)
 
     return result;
 }
-#endif
 
-#if HAVE_VIRDOMAINMIGRATE3
 static struct ruby_libvirt_typed_param migrate3_allowed[] = {
     {VIR_MIGRATE_PARAM_URI, VIR_TYPED_PARAM_STRING},
     {VIR_MIGRATE_PARAM_DEST_NAME, VIR_TYPED_PARAM_STRING},
     {VIR_MIGRATE_PARAM_DEST_XML, VIR_TYPED_PARAM_STRING},
     {VIR_MIGRATE_PARAM_BANDWIDTH, VIR_TYPED_PARAM_ULLONG},
     {VIR_MIGRATE_PARAM_GRAPHICS_URI, VIR_TYPED_PARAM_STRING},
-#if HAVE_CONST_VIR_MIGRATE_PARAM_LISTEN_ADDRESS
     {VIR_MIGRATE_PARAM_LISTEN_ADDRESS, VIR_TYPED_PARAM_STRING},
-#endif
 };
 
 /*
  * call-seq:
  *   dom.migrate3(dconn, Hash=nil, flags=0) -> Libvirt::Domain
  *
- * Call virDomainMigrate3[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrate2]
+ * Call virDomainMigrate3[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrate3]
  * to migrate a domain from the host on this connection to the connection
  * referenced in dconn.
  */
@@ -3919,7 +3658,7 @@ static VALUE libvirt_domain_migrate3(int argc, VALUE *argv, VALUE d)
  * call-seq:
  *   dom.migrate_to_uri3(duri=nil, Hash=nil, flags=0) -> nil
  *
- * Call virDomainMigrateToURI3[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateToURI3]
+ * Call virDomainMigrateToURI3[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainMigrateToURI3]
  * to migrate a domain from the host on this connection to the host whose
  * libvirt URI is duri.
  */
@@ -3955,14 +3694,12 @@ static VALUE libvirt_domain_migrate_to_uri3(int argc, VALUE *argv, VALUE d)
                                    args.params, args.i,
                                    ruby_libvirt_value_to_ulong(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINGETCPUSTATS
 /*
  * call-seq:
  *   dom.cpu_stats(start_cpu=-1, numcpus=1, flags=0) -> Hash
  *
- * Call virDomainGetCPUStats[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetCPUStats]
+ * Call virDomainGetCPUStats[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetCPUStats]
  * to get statistics about CPU usage attributable to a single domain.  If
  * start_cpu is -1, then numcpus must be 1 and statistics attributable to the
  * entire domain is returned.  If start_cpu is any positive number, then it
@@ -4048,13 +3785,11 @@ static VALUE libvirt_domain_cpu_stats(int argc, VALUE *argv, VALUE d)
 
     return result;
 }
-#endif
 
-#if HAVE_VIRDOMAINGETTIME
 /*
  * call-seq:
  *   dom.time(flags=0) -> Hash
- * Call virDomainGetTime[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetTime]
+ * Call virDomainGetTime[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetTime]
  * to get information about the guest time.
  */
 static VALUE libvirt_domain_get_time(int argc, VALUE *argv, VALUE d)
@@ -4077,13 +3812,11 @@ static VALUE libvirt_domain_get_time(int argc, VALUE *argv, VALUE d)
 
     return result;
 }
-#endif
 
-#if HAVE_VIRDOMAINSETTIME
 /*
  * call-seq:
  *   dom.time = Hash,flags=0
- * Call virDomainSetTime[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetTime]
+ * Call virDomainSetTime[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetTime]
  * to set guest time.
  */
 static VALUE libvirt_domain_time_equal(VALUE d, VALUE in)
@@ -4101,14 +3834,12 @@ static VALUE libvirt_domain_time_equal(VALUE d, VALUE in)
                                    NUM2LL(seconds), NUM2UINT(nseconds),
                                    NUM2UINT(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINCOREDUMPWITHFORMAT
 /*
  * call-seq:
  *   dom.core_dump_with_format(filename, dumpformat, flags=0) -> nil
  *
- * Call virDomainCoreDumpWithFormat[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainCoreDump]
+ * Call virDomainCoreDumpWithFormat[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainCoreDump]
  * to do a full memory dump of the domain to filename.
  */
 static VALUE libvirt_domain_core_dump_with_format(int argc, VALUE *argv, VALUE d)
@@ -4124,14 +3855,12 @@ static VALUE libvirt_domain_core_dump_with_format(int argc, VALUE *argv, VALUE d
                                    NUM2UINT(dumpformat),
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINFSFREEZE
 /*
  * call-seq:
  *   dom.fs_freeze(mountpoints=nil, flags=0) -> Fixnum
  *
- * Call virDomainFSFreeze[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainFSFreeze]
+ * Call virDomainFSFreeze[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainFSFreeze]
  * to freeze the specified filesystems within the guest.
  */
 static VALUE libvirt_domain_fs_freeze(int argc, VALUE *argv, VALUE d)
@@ -4165,14 +3894,12 @@ static VALUE libvirt_domain_fs_freeze(int argc, VALUE *argv, VALUE d)
                                    mnt, nmountpoints,
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
- #if HAVE_VIRDOMAINFSTHAW
 /*
  * call-seq:
  *   dom.fs_thaw(mountpoints=nil, flags=0) -> Fixnum
  *
- * Call virDomainFSThaw[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainFSThaw]
+ * Call virDomainFSThaw[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainFSThaw]
  * to thaw the specified filesystems within the guest.
  */
 static VALUE libvirt_domain_fs_thaw(int argc, VALUE *argv, VALUE d)
@@ -4206,9 +3933,7 @@ static VALUE libvirt_domain_fs_thaw(int argc, VALUE *argv, VALUE d)
                                    mnt, nmountpoints,
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINGETFSINFO
 struct fs_info_arg {
     virDomainFSInfoPtr *info;
     int ninfo;
@@ -4247,7 +3972,7 @@ static VALUE fs_info_wrap(VALUE arg)
  * call-seq:
  *   dom.fs_info(flags=0) -> [Hash]
  *
- * Call virDomainGetFSInfo[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetFSInfo]
+ * Call virDomainGetFSInfo[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainGetFSInfo]
  * to get information about the guest filesystems.
  */
 static VALUE libvirt_domain_fs_info(int argc, VALUE *argv, VALUE d)
@@ -4279,14 +4004,12 @@ static VALUE libvirt_domain_fs_info(int argc, VALUE *argv, VALUE d)
 
     return result;
 }
-#endif
 
-#if HAVE_VIRDOMAINRENAME
 /*
  * call-seq:
  *   dom.rename(name, flags=0) -> nil
  *
- * Call virDomainRename[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainRename]
+ * Call virDomainRename[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainRename]
  * to rename a domain.
  */
 static VALUE libvirt_domain_rename(int argc, VALUE *argv, VALUE d)
@@ -4301,14 +4024,12 @@ static VALUE libvirt_domain_rename(int argc, VALUE *argv, VALUE d)
                                    StringValueCStr(name),
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
-#if HAVE_VIRDOMAINSETUSERPASSWORD
 /*
  * call-seq:
  *   dom.user_password = user,password,flags=0 -> nil
  *
- * Call virDomainSetUserPassword[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetUserPassword]
+ * Call virDomainSetUserPassword[https://libvirt.org/html/libvirt-libvirt-domain.html#virDomainSetUserPassword]
  * to set the user password on a domain.
  */
 static VALUE libvirt_domain_user_password_equal(VALUE d, VALUE in)
@@ -4339,7 +4060,6 @@ static VALUE libvirt_domain_user_password_equal(VALUE d, VALUE in)
                                    StringValueCStr(password),
                                    ruby_libvirt_value_to_uint(flags));
 }
-#endif
 
 /*
  * Class Libvirt::Domain
@@ -4355,67 +4075,35 @@ void ruby_libvirt_domain_init(void)
     rb_define_const(c_domain, "SHUTDOWN", INT2NUM(VIR_DOMAIN_SHUTDOWN));
     rb_define_const(c_domain, "SHUTOFF", INT2NUM(VIR_DOMAIN_SHUTOFF));
     rb_define_const(c_domain, "CRASHED", INT2NUM(VIR_DOMAIN_CRASHED));
-#if HAVE_CONST_VIR_DOMAIN_PMSUSPENDED
     rb_define_const(c_domain, "PMSUSPENDED", INT2NUM(VIR_DOMAIN_PMSUSPENDED));
-#endif
 
     /* virDomainMigrateFlags */
-#if HAVE_CONST_VIR_MIGRATE_LIVE
     rb_define_const(c_domain, "MIGRATE_LIVE", INT2NUM(VIR_MIGRATE_LIVE));
-#endif
-#if HAVE_CONST_VIR_MIGRATE_PEER2PEER
     rb_define_const(c_domain, "MIGRATE_PEER2PEER",
                     INT2NUM(VIR_MIGRATE_PEER2PEER));
-#endif
-#if HAVE_CONST_VIR_MIGRATE_TUNNELLED
     rb_define_const(c_domain, "MIGRATE_TUNNELLED",
                     INT2NUM(VIR_MIGRATE_TUNNELLED));
-#endif
-#if HAVE_CONST_VIR_MIGRATE_PERSIST_DEST
     rb_define_const(c_domain, "MIGRATE_PERSIST_DEST",
                     INT2NUM(VIR_MIGRATE_PERSIST_DEST));
-#endif
-#if HAVE_CONST_VIR_MIGRATE_UNDEFINE_SOURCE
     rb_define_const(c_domain, "MIGRATE_UNDEFINE_SOURCE",
                     INT2NUM(VIR_MIGRATE_UNDEFINE_SOURCE));
-#endif
-#if HAVE_CONST_VIR_MIGRATE_PAUSED
     rb_define_const(c_domain, "MIGRATE_PAUSED", INT2NUM(VIR_MIGRATE_PAUSED));
-#endif
-#if HAVE_CONST_VIR_MIGRATE_NON_SHARED_DISK
     rb_define_const(c_domain, "MIGRATE_NON_SHARED_DISK",
                     INT2NUM(VIR_MIGRATE_NON_SHARED_DISK));
-#endif
-#if HAVE_CONST_VIR_MIGRATE_NON_SHARED_INC
     rb_define_const(c_domain, "MIGRATE_NON_SHARED_INC",
                     INT2NUM(VIR_MIGRATE_NON_SHARED_INC));
-#endif
-#if HAVE_CONST_VIR_MIGRATE_CHANGE_PROTECTION
     rb_define_const(c_domain, "MIGRATE_CHANGE_PROTECTION",
                     INT2NUM(VIR_MIGRATE_CHANGE_PROTECTION));
-#endif
-#if HAVE_CONST_VIR_MIGRATE_UNSAFE
     rb_define_const(c_domain, "MIGRATE_UNSAFE", INT2NUM(VIR_MIGRATE_UNSAFE));
-#endif
-#if HAVE_CONST_VIR_MIGRATE_OFFLINE
     rb_define_const(c_domain, "MIGRATE_OFFLINE", INT2NUM(VIR_MIGRATE_OFFLINE));
-#endif
-#if HAVE_CONST_VIR_MIGRATE_COMPRESSED
     rb_define_const(c_domain, "MIGRATE_COMPRESSED",
                     INT2NUM(VIR_MIGRATE_COMPRESSED));
-#endif
-#if HAVE_CONST_VIR_MIGRATE_ABORT_ON_ERROR
     rb_define_const(c_domain, "MIGRATE_ABORT_ON_ERROR",
                     INT2NUM(VIR_MIGRATE_ABORT_ON_ERROR));
-#endif
-#if HAVE_CONST_VIR_MIGRATE_AUTO_CONVERGE
     rb_define_const(c_domain, "MIGRATE_AUTO_CONVERGE",
                     INT2NUM(VIR_MIGRATE_AUTO_CONVERGE));
-#endif
-#if HAVE_CONST_VIR_MIGRATE_RDMA_PIN_ALL
     rb_define_const(c_domain, "MIGRATE_RDMA_PIN_ALL",
                     INT2NUM(VIR_MIGRATE_RDMA_PIN_ALL));
-#endif
 
     /* Ideally we would just have the "XML_SECURE" constant.  Unfortunately
      * we screwed up long ago, and we have to leave "DOMAIN_XML_SECURE" for
@@ -4431,7 +4119,6 @@ void ruby_libvirt_domain_init(void)
     rb_define_const(c_domain, "XML_INACTIVE", INT2NUM(VIR_DOMAIN_XML_INACTIVE));
     rb_define_const(c_domain, "DOMAIN_XML_INACTIVE",
                     INT2NUM(VIR_DOMAIN_XML_INACTIVE));
-#if HAVE_CONST_VIR_DOMAIN_XML_UPDATE_CPU
     /* Ideally we would just have the "XML_UPDATE_CPU" constant.  Unfortunately
      * we screwed up long ago, and we have to leave "DOMAIN_XML_UPDATE_CPU" for
      * backwards compatibility.
@@ -4440,77 +4127,39 @@ void ruby_libvirt_domain_init(void)
                     INT2NUM(VIR_DOMAIN_XML_UPDATE_CPU));
     rb_define_const(c_domain, "DOMAIN_XML_UPDATE_CPU",
                     INT2NUM(VIR_DOMAIN_XML_UPDATE_CPU));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_XML_MIGRATABLE
     rb_define_const(c_domain, "XML_MIGRATABLE",
                     INT2NUM(VIR_DOMAIN_XML_MIGRATABLE));
-#endif
-#if HAVE_VIRDOMAINMEMORYPEEK
     rb_define_const(c_domain, "MEMORY_VIRTUAL", INT2NUM(VIR_MEMORY_VIRTUAL));
-#endif
-#if HAVE_CONST_VIR_MEMORY_PHYSICAL
     rb_define_const(c_domain, "MEMORY_PHYSICAL", INT2NUM(VIR_MEMORY_PHYSICAL));
-#endif
 
-#if HAVE_CONST_VIR_DOMAIN_START_PAUSED
     rb_define_const(c_domain, "START_PAUSED", INT2NUM(VIR_DOMAIN_START_PAUSED));
-#endif
 
-#if HAVE_CONST_VIR_DOMAIN_START_AUTODESTROY
     rb_define_const(c_domain, "START_AUTODESTROY",
                     INT2NUM(VIR_DOMAIN_START_AUTODESTROY));
-#endif
-
-#if HAVE_CONST_VIR_DOMAIN_START_BYPASS_CACHE
     rb_define_const(c_domain, "START_BYPASS_CACHE",
                     INT2NUM(VIR_DOMAIN_START_BYPASS_CACHE));
-#endif
-
-#if HAVE_CONST_VIR_DOMAIN_START_FORCE_BOOT
     rb_define_const(c_domain, "START_FORCE_BOOT",
                     INT2NUM(VIR_DOMAIN_START_FORCE_BOOT));
-#endif
 
-#if HAVE_CONST_VIR_DUMP_CRASH
     rb_define_const(c_domain, "DUMP_CRASH", INT2NUM(VIR_DUMP_CRASH));
-#endif
-#if HAVE_CONST_VIR_DUMP_LIVE
     rb_define_const(c_domain, "DUMP_LIVE", INT2NUM(VIR_DUMP_LIVE));
-#endif
-#if HAVE_CONST_VIR_DUMP_BYPASS_CACHE
     rb_define_const(c_domain, "BYPASS_CACHE", INT2NUM(VIR_DUMP_BYPASS_CACHE));
-#endif
-#if HAVE_CONST_VIR_DUMP_RESET
     rb_define_const(c_domain, "RESET", INT2NUM(VIR_DUMP_RESET));
-#endif
-#if HAVE_CONST_VIR_DUMP_MEMORY_ONLY
     rb_define_const(c_domain, "MEMORY_ONLY", INT2NUM(VIR_DUMP_MEMORY_ONLY));
-#endif
 
-#if HAVE_VIRDOMAINGETVCPUSFLAGS
     rb_define_const(c_domain, "VCPU_LIVE", INT2NUM(VIR_DOMAIN_VCPU_LIVE));
     rb_define_const(c_domain, "VCPU_CONFIG", INT2NUM(VIR_DOMAIN_VCPU_CONFIG));
     rb_define_const(c_domain, "VCPU_MAXIMUM", INT2NUM(VIR_DOMAIN_VCPU_MAXIMUM));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_VCPU_CURRENT
     rb_define_const(c_domain, "VCPU_CURRENT", INT2NUM(VIR_DOMAIN_VCPU_CURRENT));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_VCPU_GUEST
     rb_define_const(c_domain, "VCPU_GUEST", INT2NUM(VIR_DOMAIN_VCPU_GUEST));
-#endif
 
     rb_define_method(c_domain, "migrate", libvirt_domain_migrate, -1);
-#if HAVE_VIRDOMAINMIGRATETOURI
     rb_define_method(c_domain, "migrate_to_uri",
                      libvirt_domain_migrate_to_uri, -1);
-#endif
-#if HAVE_VIRDOMAINMIGRATESETMAXDOWNTIME
     rb_define_method(c_domain, "migrate_set_max_downtime",
                      libvirt_domain_migrate_set_max_downtime, -1);
     rb_define_method(c_domain, "migrate_max_downtime=",
                      libvirt_domain_migrate_max_downtime_equal, 1);
-#endif
-#if HAVE_VIRDOMAINMIGRATE2
     rb_define_method(c_domain, "migrate2", libvirt_domain_migrate2, -1);
     rb_define_method(c_domain, "migrate_to_uri2",
                      libvirt_domain_migrate_to_uri2, -1);
@@ -4518,92 +4167,60 @@ void ruby_libvirt_domain_init(void)
                      libvirt_domain_migrate_set_max_speed, -1);
     rb_define_method(c_domain, "migrate_max_speed=",
                      libvirt_domain_migrate_max_speed_equal, 1);
-#endif
 
-#if HAVE_CONST_VIR_DOMAIN_SAVE_BYPASS_CACHE
     rb_define_const(c_domain, "SAVE_BYPASS_CACHE",
                     INT2NUM(VIR_DOMAIN_SAVE_BYPASS_CACHE));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_SAVE_RUNNING
     rb_define_const(c_domain, "SAVE_RUNNING", INT2NUM(VIR_DOMAIN_SAVE_RUNNING));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_SAVE_PAUSED
     rb_define_const(c_domain, "SAVE_PAUSED", INT2NUM(VIR_DOMAIN_SAVE_PAUSED));
-#endif
 
-#if HAVE_CONST_VIR_DOMAIN_UNDEFINE_MANAGED_SAVE
     rb_define_const(c_domain, "UNDEFINE_MANAGED_SAVE",
                     INT2NUM(VIR_DOMAIN_UNDEFINE_MANAGED_SAVE));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_UNDEFINE_SNAPSHOTS_METADATA
     rb_define_const(c_domain, "UNDEFINE_SNAPSHOTS_METADATA",
                     INT2NUM(VIR_DOMAIN_UNDEFINE_SNAPSHOTS_METADATA));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_UNDEFINE_NVRAM
     rb_define_const(c_domain, "UNDEFINE_NVRAM",
                     INT2NUM(VIR_DOMAIN_UNDEFINE_NVRAM));
+#if LIBVIR_CHECK_VERSION(2, 3, 0)
+    rb_define_const(c_domain, "UNDEFINE_KEEP_NVRAM",
+                    INT2NUM(VIR_DOMAIN_UNDEFINE_KEEP_NVRAM));
+#endif
+#if LIBVIR_CHECK_VERSION(5, 6, 0)
+    rb_define_const(c_domain, "UNDEFINE_CHECKPOINTS_METADATA",
+                    INT2NUM(VIR_DOMAIN_UNDEFINE_CHECKPOINTS_METADATA));
 #endif
     rb_define_attr(c_domain, "connection", 1, 0);
 
-#if HAVE_CONST_VIR_DOMAIN_SHUTDOWN_DEFAULT
     rb_define_const(c_domain, "SHUTDOWN_DEFAULT",
                     INT2NUM(VIR_DOMAIN_SHUTDOWN_DEFAULT));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_SHUTDOWN_ACPI_POWER_BTN
     rb_define_const(c_domain, "SHUTDOWN_ACPI_POWER_BTN",
                     INT2NUM(VIR_DOMAIN_SHUTDOWN_ACPI_POWER_BTN));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_SHUTDOWN_GUEST_AGENT
     rb_define_const(c_domain, "SHUTDOWN_GUEST_AGENT",
                     INT2NUM(VIR_DOMAIN_SHUTDOWN_GUEST_AGENT));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_SHUTDOWN_INITCTL
     rb_define_const(c_domain, "SHUTDOWN_INITCTL",
                     INT2NUM(VIR_DOMAIN_SHUTDOWN_INITCTL));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_SHUTDOWN_SIGNAL
     rb_define_const(c_domain, "SHUTDOWN_SIGNAL",
                     INT2NUM(VIR_DOMAIN_SHUTDOWN_SIGNAL));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_SHUTDOWN_PARAVIRT
     rb_define_const(c_domain, "SHUTDOWN_PARAVIRT",
                     INT2NUM(VIR_DOMAIN_SHUTDOWN_PARAVIRT));
-#endif
     rb_define_method(c_domain, "shutdown", libvirt_domain_shutdown, -1);
 
-#if HAVE_CONST_VIR_DOMAIN_REBOOT_DEFAULT
     rb_define_const(c_domain, "REBOOT_DEFAULT",
                     INT2NUM(VIR_DOMAIN_REBOOT_DEFAULT));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_REBOOT_ACPI_POWER_BTN
     rb_define_const(c_domain, "REBOOT_ACPI_POWER_BTN",
                     INT2NUM(VIR_DOMAIN_REBOOT_ACPI_POWER_BTN));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_REBOOT_GUEST_AGENT
     rb_define_const(c_domain, "REBOOT_GUEST_AGENT",
                     INT2NUM(VIR_DOMAIN_REBOOT_GUEST_AGENT));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_REBOOT_INITCTL
     rb_define_const(c_domain, "REBOOT_INITCTL",
                     INT2NUM(VIR_DOMAIN_REBOOT_INITCTL));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_REBOOT_SIGNAL
     rb_define_const(c_domain, "REBOOT_SIGNAL",
                     INT2NUM(VIR_DOMAIN_REBOOT_SIGNAL));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_REBOOT_PARAVIRT
     rb_define_const(c_domain, "REBOOT_PARAVIRT",
                     INT2NUM(VIR_DOMAIN_REBOOT_PARAVIRT));
-#endif
     rb_define_method(c_domain, "reboot", libvirt_domain_reboot, -1);
-#if HAVE_CONST_VIR_DOMAIN_DESTROY_DEFAULT
+
     rb_define_const(c_domain, "DESTROY_DEFAULT",
                     INT2NUM(VIR_DOMAIN_DESTROY_DEFAULT));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_DESTROY_GRACEFUL
     rb_define_const(c_domain, "DESTROY_GRACEFUL",
                     INT2NUM(VIR_DOMAIN_DESTROY_GRACEFUL));
-#endif
     rb_define_method(c_domain, "destroy", libvirt_domain_destroy, -1);
     rb_define_method(c_domain, "suspend", libvirt_domain_suspend, 0);
     rb_define_method(c_domain, "resume", libvirt_domain_resume, 0);
@@ -4623,10 +4240,8 @@ void ruby_libvirt_domain_init(void)
     rb_define_method(c_domain, "memory=", libvirt_domain_memory_equal, 1);
     rb_define_method(c_domain, "max_vcpus", libvirt_domain_max_vcpus, 0);
     rb_define_method(c_domain, "vcpus=", libvirt_domain_vcpus_equal, 1);
-#if HAVE_VIRDOMAINSETVCPUSFLAGS
     rb_define_method(c_domain, "vcpus_flags=", libvirt_domain_vcpus_flags_equal,
                      1);
-#endif
     rb_define_method(c_domain, "pin_vcpu", libvirt_domain_pin_vcpu, -1);
     rb_define_method(c_domain, "xml_desc", libvirt_domain_xml_desc, -1);
     rb_define_method(c_domain, "undefine", libvirt_domain_undefine, -1);
@@ -4636,67 +4251,41 @@ void ruby_libvirt_domain_init(void)
     rb_define_method(c_domain, "autostart=", libvirt_domain_autostart_equal, 1);
     rb_define_method(c_domain, "free", libvirt_domain_free, 0);
 
-#if HAVE_CONST_VIR_DOMAIN_DEVICE_MODIFY_CURRENT
     rb_define_const(c_domain, "DEVICE_MODIFY_CURRENT",
                     INT2NUM(VIR_DOMAIN_DEVICE_MODIFY_CURRENT));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_DEVICE_MODIFY_LIVE
     rb_define_const(c_domain, "DEVICE_MODIFY_LIVE",
                     INT2NUM(VIR_DOMAIN_DEVICE_MODIFY_LIVE));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_DEVICE_MODIFY_CONFIG
     rb_define_const(c_domain, "DEVICE_MODIFY_CONFIG",
                     INT2NUM(VIR_DOMAIN_DEVICE_MODIFY_CONFIG));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_DEVICE_MODIFY_FORCE
     rb_define_const(c_domain, "DEVICE_MODIFY_FORCE",
                     INT2NUM(VIR_DOMAIN_DEVICE_MODIFY_FORCE));
-#endif
+
     rb_define_method(c_domain, "attach_device", libvirt_domain_attach_device,
                      -1);
     rb_define_method(c_domain, "detach_device", libvirt_domain_detach_device,
                      -1);
-#if HAVE_VIRDOMAINUPDATEDEVICEFLAGS
     rb_define_method(c_domain, "update_device", libvirt_domain_update_device,
                      -1);
-#endif
 
     rb_define_method(c_domain, "scheduler_type", libvirt_domain_scheduler_type,
                      0);
 
-#if HAVE_VIRDOMAINMANAGEDSAVE
     rb_define_method(c_domain, "managed_save", libvirt_domain_managed_save, -1);
     rb_define_method(c_domain, "has_managed_save?",
                      libvirt_domain_has_managed_save, -1);
     rb_define_method(c_domain, "managed_save_remove",
                      libvirt_domain_managed_save_remove, -1);
-#endif
-#if HAVE_VIRDOMAINGETSECURITYLABEL
     rb_define_method(c_domain, "security_label",
                      libvirt_domain_security_label, 0);
-#endif
     rb_define_method(c_domain, "block_stats", libvirt_domain_block_stats, 1);
-#if HAVE_TYPE_VIRDOMAINMEMORYSTATPTR
     rb_define_method(c_domain, "memory_stats", libvirt_domain_memory_stats, -1);
-#endif
-#if HAVE_VIRDOMAINBLOCKPEEK
     rb_define_method(c_domain, "block_peek", libvirt_domain_block_peek, -1);
-#endif
-#if HAVE_TYPE_VIRDOMAINBLOCKINFOPTR
     rb_define_method(c_domain, "blockinfo", libvirt_domain_block_info, -1);
-#endif
-#if HAVE_VIRDOMAINMEMORYPEEK
     rb_define_method(c_domain, "memory_peek", libvirt_domain_memory_peek, -1);
-#endif
     rb_define_method(c_domain, "vcpus", libvirt_domain_vcpus, 0);
     rb_define_alias(c_domain, "get_vcpus", "vcpus");
-#if HAVE_VIRDOMAINISACTIVE
     rb_define_method(c_domain, "active?", libvirt_domain_active_p, 0);
-#endif
-#if HAVE_VIRDOMAINISPERSISTENT
     rb_define_method(c_domain, "persistent?", libvirt_domain_persistent_p, 0);
-#endif
-#if HAVE_TYPE_VIRDOMAINSNAPSHOTPTR
     rb_define_method(c_domain, "snapshot_create_xml",
                      libvirt_domain_snapshot_create_xml, -1);
     rb_define_method(c_domain, "num_of_snapshots",
@@ -4711,7 +4300,6 @@ void ruby_libvirt_domain_init(void)
                      libvirt_domain_revert_to_snapshot, -1);
     rb_define_method(c_domain, "current_snapshot",
                      libvirt_domain_current_snapshot, -1);
-#endif
 
     /*
      * Class Libvirt::Domain::Info
@@ -4756,7 +4344,6 @@ void ruby_libvirt_domain_init(void)
     rb_define_attr(c_domain_block_stats, "wr_bytes", 1, 0);
     rb_define_attr(c_domain_block_stats, "errs", 1, 0);
 
-#if HAVE_TYPE_VIRDOMAINBLOCKJOBINFOPTR
     /*
      * Class Libvirt::Domain::BlockJobInfo
      */
@@ -4766,9 +4353,7 @@ void ruby_libvirt_domain_init(void)
     rb_define_attr(c_domain_block_job_info, "bandwidth", 1, 0);
     rb_define_attr(c_domain_block_job_info, "cur", 1, 0);
     rb_define_attr(c_domain_block_job_info, "end", 1, 0);
-#endif
 
-#if HAVE_TYPE_VIRDOMAINMEMORYSTATPTR
     /*
      * Class Libvirt::Domain::MemoryStats
      */
@@ -4789,17 +4374,11 @@ void ruby_libvirt_domain_init(void)
                     INT2NUM(VIR_DOMAIN_MEMORY_STAT_UNUSED));
     rb_define_const(c_domain_memory_stats, "AVAILABLE",
                     INT2NUM(VIR_DOMAIN_MEMORY_STAT_AVAILABLE));
-#if HAVE_CONST_VIR_DOMAIN_MEMORY_STAT_ACTUAL_BALLOON
     rb_define_const(c_domain_memory_stats, "ACTUAL_BALLOON",
                     INT2NUM(VIR_DOMAIN_MEMORY_STAT_ACTUAL_BALLOON));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_MEMORY_STATE_RSS
     rb_define_const(c_domain_memory_stats, "RSS",
                     INT2NUM(VIR_DOMAIN_MEMORY_STAT_RSS));
-#endif
-#endif
 
-#if HAVE_TYPE_VIRDOMAINBLOCKINFOPTR
     /*
      * Class Libvirt::Domain::BlockInfo
      */
@@ -4808,9 +4387,7 @@ void ruby_libvirt_domain_init(void)
     rb_define_attr(c_domain_block_info, "capacity", 1, 0);
     rb_define_attr(c_domain_block_info, "allocation", 1, 0);
     rb_define_attr(c_domain_block_info, "physical", 1, 0);
-#endif
 
-#if HAVE_TYPE_VIRDOMAINSNAPSHOTPTR
     /*
      * Class Libvirt::Domain::Snapshot
      */
@@ -4823,20 +4400,13 @@ void ruby_libvirt_domain_init(void)
                      libvirt_domain_snapshot_delete, -1);
     rb_define_method(c_domain_snapshot, "free", libvirt_domain_snapshot_free,
                      0);
-#if HAVE_CONST_VIR_DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY
     rb_define_const(c_domain_snapshot, "DELETE_METADATA_ONLY",
                     INT2NUM(VIR_DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY
     rb_define_const(c_domain_snapshot, "DELETE_CHILDREN_ONLY",
                     INT2NUM(VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY));
-#endif
 
-#endif
-#if HAVE_VIRDOMAINSNAPSHOTGETNAME
     rb_define_method(c_domain_snapshot, "name", libvirt_domain_snapshot_name,
                      0);
-#endif
 
     /*
      * Class Libvirt::Domain::VCPUInfo
@@ -4851,7 +4421,6 @@ void ruby_libvirt_domain_init(void)
     rb_define_attr(c_domain_vcpuinfo, "cpu", 1, 0);
     rb_define_attr(c_domain_vcpuinfo, "cpumap", 1, 0);
 
-#if HAVE_TYPE_VIRDOMAINJOBINFOPTR
     /*
      * Class Libvirt::Domain::JobInfo
      */
@@ -4882,27 +4451,17 @@ void ruby_libvirt_domain_init(void)
 
     rb_define_method(c_domain, "job_info", libvirt_domain_job_info, 0);
     rb_define_method(c_domain, "abort_job", libvirt_domain_abort_job, 0);
-#endif
 
-#if HAVE_VIRDOMAINQEMUMONITORCOMMAND
     rb_define_method(c_domain, "qemu_monitor_command",
                      libvirt_domain_qemu_monitor_command, -1);
-#endif
 
-#if HAVE_VIRDOMAINGETVCPUSFLAGS
     rb_define_method(c_domain, "num_vcpus", libvirt_domain_num_vcpus, 1);
-#endif
 
-#if HAVE_VIRDOMAINISUPDATED
     rb_define_method(c_domain, "updated?", libvirt_domain_is_updated, 0);
-#endif
 
-#ifdef VIR_DOMAIN_MEMORY_PARAM_UNLIMITED
     rb_define_const(c_domain, "MEMORY_PARAM_UNLIMITED",
                     LL2NUM(VIR_DOMAIN_MEMORY_PARAM_UNLIMITED));
-#endif
 
-#if HAVE_VIRDOMAINSETMEMORYFLAGS
     /* Ideally we would just have the "MEM_LIVE" constant.  Unfortunately
      * we screwed up long ago, and we have to leave "DOMAIN_MEM_LIVE" for
      * backwards compatibility.
@@ -4916,8 +4475,7 @@ void ruby_libvirt_domain_init(void)
     rb_define_const(c_domain, "MEM_CONFIG", INT2NUM(VIR_DOMAIN_MEM_CONFIG));
     rb_define_const(c_domain, "DOMAIN_MEM_CONFIG",
                     INT2NUM(VIR_DOMAIN_MEM_CONFIG));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_MEM_CURRENT
+
     /* Ideally we would just have the "MEM_CURRENT" constant.  Unfortunately
      * we screwed up long ago, and we have to leave "DOMAIN_MEM_CURRENT" for
      * backwards compatibility.
@@ -4932,28 +4490,22 @@ void ruby_libvirt_domain_init(void)
     rb_define_const(c_domain, "MEM_MAXIMUM", INT2NUM(VIR_DOMAIN_MEM_MAXIMUM));
     rb_define_const(c_domain, "DOMAIN_MEM_MAXIMUM",
                     INT2NUM(VIR_DOMAIN_MEM_MAXIMUM));
-#endif
 
     rb_define_method(c_domain, "scheduler_parameters",
                      libvirt_domain_scheduler_parameters, -1);
     rb_define_method(c_domain, "scheduler_parameters=",
                      libvirt_domain_scheduler_parameters_equal, 1);
 
-#if HAVE_VIRDOMAINSETMEMORYPARAMETERS
     rb_define_method(c_domain, "memory_parameters",
                      libvirt_domain_memory_parameters, -1);
     rb_define_method(c_domain, "memory_parameters=",
                      libvirt_domain_memory_parameters_equal, 1);
-#endif
 
-#if HAVE_VIRDOMAINSETBLKIOPARAMETERS
     rb_define_method(c_domain, "blkio_parameters",
                      libvirt_domain_blkio_parameters, -1);
     rb_define_method(c_domain, "blkio_parameters=",
                      libvirt_domain_blkio_parameters_equal, 1);
-#endif
 
-#if HAVE_VIRDOMAINGETSTATE
     /* Ideally we would just have the "RUNNING_UNKNOWN" constant.  Unfortunately
      * we screwed up long ago, and we have to leave "DOMAIN_RUNNING_UNKNOWN"
      * for backwards compatibility.
@@ -5018,7 +4570,6 @@ void ruby_libvirt_domain_init(void)
                     INT2NUM(VIR_DOMAIN_RUNNING_SAVE_CANCELED));
     rb_define_const(c_domain, "DOMAIN_RUNNING_SAVE_CANCELED",
                     INT2NUM(VIR_DOMAIN_RUNNING_SAVE_CANCELED));
-#if HAVE_CONST_VIR_DOMAIN_RUNNING_WAKEUP
     /* Ideally we would just have the "RUNNING_WAKEUP" constant.  Unfortunately
      * we screwed up long ago, and we have to leave "DOMAIN_RUNNING_WAKEUP"
      * for backwards compatibility.
@@ -5027,7 +4578,6 @@ void ruby_libvirt_domain_init(void)
                     INT2NUM(VIR_DOMAIN_RUNNING_WAKEUP));
     rb_define_const(c_domain, "DOMAIN_RUNNING_WAKEUP",
                     INT2NUM(VIR_DOMAIN_RUNNING_WAKEUP));
-#endif
     /* Ideally we would just have the "BLOCKED_UNKNOWN" constant.  Unfortunately
      * we screwed up long ago, and we have to leave "DOMAIN_BLOCKED_UNKNOWN"
      * for backwards compatibility.
@@ -5100,7 +4650,6 @@ void ruby_libvirt_domain_init(void)
                     INT2NUM(VIR_DOMAIN_PAUSED_FROM_SNAPSHOT));
     rb_define_const(c_domain, "DOMAIN_PAUSED_FROM_SNAPSHOT",
                     INT2NUM(VIR_DOMAIN_PAUSED_FROM_SNAPSHOT));
-#if HAVE_CONST_VIR_DOMAIN_PAUSED_SHUTTING_DOWN
     /* Ideally we would just have the "PAUSED_SHUTTING_DOWN" constant.
      * Unfortunately we screwed up long ago, and we have to leave
      * "DOMAIN_PAUSED_SHUTTING_DOWN" for backwards compatibility.
@@ -5109,8 +4658,6 @@ void ruby_libvirt_domain_init(void)
                     INT2NUM(VIR_DOMAIN_PAUSED_SHUTTING_DOWN));
     rb_define_const(c_domain, "DOMAIN_PAUSED_SHUTTING_DOWN",
                     INT2NUM(VIR_DOMAIN_PAUSED_SHUTTING_DOWN));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_PAUSED_SNAPSHOT
     /* Ideally we would just have the "PAUSED_SNAPSHOT" constant.  Unfortunately
      * we screwed up long ago, and we have to leave "DOMAIN_PAUSED_SNAPSHOT"
      * for backwards compatibility.
@@ -5119,7 +4666,6 @@ void ruby_libvirt_domain_init(void)
                     INT2NUM(VIR_DOMAIN_PAUSED_SNAPSHOT));
     rb_define_const(c_domain, "DOMAIN_PAUSED_SNAPSHOT",
                     INT2NUM(VIR_DOMAIN_PAUSED_SNAPSHOT));
-#endif
     /* Ideally we would just have the "SHUTDOWN_UNKNOWN" constant.
      * Unfortunately we screwed up long ago, and we have to leave
      * "DOMAIN_SHUTDOWN_UNKNOWN" for backwards compatibility.
@@ -5208,7 +4754,6 @@ void ruby_libvirt_domain_init(void)
                     INT2NUM(VIR_DOMAIN_CRASHED_UNKNOWN));
     rb_define_const(c_domain, "DOMAIN_CRASHED_UNKNOWN",
                     INT2NUM(VIR_DOMAIN_CRASHED_UNKNOWN));
-#if HAVE_CONST_VIR_DOMAIN_PMSUSPENDED_UNKNOWN
     /* Ideally we would just have the "PMSUSPENDED_UNKNOWN" constant.
      * Unfortunately we screwed up long ago, and we have to leave
      * "DOMAIN_PMSUSPENDED_UNKNOWN" for backwards compatibility.
@@ -5217,8 +4762,6 @@ void ruby_libvirt_domain_init(void)
                     INT2NUM(VIR_DOMAIN_PMSUSPENDED_UNKNOWN));
     rb_define_const(c_domain, "DOMAIN_PMSUSPENDED_UNKNOWN",
                     INT2NUM(VIR_DOMAIN_PMSUSPENDED_UNKNOWN));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_PMSUSPENDED_DISK_UNKNOWN
     /* Ideally we would just have the "PMSUSPENDED_DISK_UNKNOWN" constant.
      * Unfortunately we screwed up long ago, and we have to leave
      * "DOMAIN_PMSUSPENDED_DISK_UNKNOWN" for backwards compatibility.
@@ -5227,28 +4770,17 @@ void ruby_libvirt_domain_init(void)
                     INT2NUM(VIR_DOMAIN_PMSUSPENDED_DISK_UNKNOWN));
     rb_define_const(c_domain, "DOMAIN_PMSUSPENDED_DISK_UNKNOWN",
                     INT2NUM(VIR_DOMAIN_PMSUSPENDED_DISK_UNKNOWN));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_RUNNING_CRASHED
     rb_define_const(c_domain, "RUNNING_CRASHED",
                     INT2NUM(VIR_DOMAIN_RUNNING_CRASHED));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_NOSTATE_UNKNOWN
     rb_define_const(c_domain, "NOSTATE_UNKNOWN",
                     INT2NUM(VIR_DOMAIN_NOSTATE_UNKNOWN));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_PAUSED_CRASHED
     rb_define_const(c_domain, "PAUSED_CRASHED",
                     INT2NUM(VIR_DOMAIN_PAUSED_CRASHED));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_CRASHED_PANICKED
     rb_define_const(c_domain, "CRASHED_PANICKED",
                     INT2NUM(VIR_DOMAIN_CRASHED_PANICKED));
-#endif
 
     rb_define_method(c_domain, "state", libvirt_domain_state, -1);
-#endif
 
-#if HAVE_CONST_VIR_DOMAIN_AFFECT_CURRENT
     /* Ideally we would just have the "AFFECT_CURRENT" constant.  Unfortunately
      * we screwed up long ago, and we have to leave "DOMAIN_AFFECT_CURRENT" for
      * backwards compatibility.
@@ -5273,29 +4805,17 @@ void ruby_libvirt_domain_init(void)
                     INT2NUM(VIR_DOMAIN_AFFECT_CONFIG));
     rb_define_const(c_domain, "DOMAIN_AFFECT_CONFIG",
                     INT2NUM(VIR_DOMAIN_AFFECT_CONFIG));
-#endif
 
-#if HAVE_CONST_VIR_DOMAIN_CONSOLE_FORCE
     rb_define_const(c_domain, "CONSOLE_FORCE",
                     INT2NUM(VIR_DOMAIN_CONSOLE_FORCE));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_CONSOLE_SAFE
     rb_define_const(c_domain, "CONSOLE_SAFE", INT2NUM(VIR_DOMAIN_CONSOLE_SAFE));
-#endif
 
-#if HAVE_VIRDOMAINOPENCONSOLE
     rb_define_method(c_domain, "open_console", libvirt_domain_open_console, -1);
-#endif
 
-#if HAVE_VIRDOMAINSCREENSHOT
     rb_define_method(c_domain, "screenshot", libvirt_domain_screenshot, -1);
-#endif
 
-#if HAVE_VIRDOMAININJECTNMI
     rb_define_method(c_domain, "inject_nmi", libvirt_domain_inject_nmi, -1);
-#endif
 
-#if HAVE_VIRDOMAINGETCONTROLINFO
     /*
      * Class Libvirt::Domain::ControlInfo
      */
@@ -5315,22 +4835,12 @@ void ruby_libvirt_domain_init(void)
                     INT2NUM(VIR_DOMAIN_CONTROL_ERROR));
 
     rb_define_method(c_domain, "control_info", libvirt_domain_control_info, -1);
-#endif
 
-#if HAVE_VIRDOMAINMIGRATEGETMAXSPEED
     rb_define_method(c_domain, "migrate_max_speed",
                      libvirt_domain_migrate_max_speed, -1);
-#endif
-#if HAVE_VIRDOMAINSENDKEY
     rb_define_method(c_domain, "send_key", libvirt_domain_send_key, 3);
-#endif
-#if HAVE_VIRDOMAINRESET
     rb_define_method(c_domain, "reset", libvirt_domain_reset, -1);
-#endif
-#if HAVE_VIRDOMAINGETHOSTNAME
     rb_define_method(c_domain, "hostname", libvirt_domain_hostname, -1);
-#endif
-#if HAVE_VIRDOMAINGETMETADATA
     rb_define_const(c_domain, "METADATA_DESCRIPTION",
                     INT2NUM(VIR_DOMAIN_METADATA_DESCRIPTION));
     rb_define_const(c_domain, "METADATA_TITLE",
@@ -5338,11 +4848,7 @@ void ruby_libvirt_domain_init(void)
     rb_define_const(c_domain, "METADATA_ELEMENT",
                     INT2NUM(VIR_DOMAIN_METADATA_ELEMENT));
     rb_define_method(c_domain, "metadata", libvirt_domain_metadata, -1);
-#endif
-#if HAVE_VIRDOMAINSETMETADATA
     rb_define_method(c_domain, "metadata=", libvirt_domain_metadata_equal, 1);
-#endif
-#if HAVE_VIRDOMAINSENDPROCESSSIGNAL
     rb_define_const(c_domain, "PROCESS_SIGNAL_NOP",
                     INT2NUM(VIR_DOMAIN_PROCESS_SIGNAL_NOP));
     rb_define_const(c_domain, "PROCESS_SIGNAL_HUP",
@@ -5475,8 +4981,6 @@ void ruby_libvirt_domain_init(void)
                     INT2NUM(VIR_DOMAIN_PROCESS_SIGNAL_RT32));
     rb_define_method(c_domain, "send_process_signal",
                      libvirt_domain_send_process_signal, -1);
-#endif
-#if HAVE_VIRDOMAINLISTALLSNAPSHOTS
     rb_define_const(c_domain_snapshot, "LIST_ROOTS",
                     INT2NUM(VIR_DOMAIN_SNAPSHOT_LIST_ROOTS));
     rb_define_const(c_domain_snapshot, "LIST_DESCENDANTS",
@@ -5489,7 +4993,6 @@ void ruby_libvirt_domain_init(void)
                     INT2NUM(VIR_DOMAIN_SNAPSHOT_LIST_METADATA));
     rb_define_const(c_domain_snapshot, "LIST_NO_METADATA",
                     INT2NUM(VIR_DOMAIN_SNAPSHOT_LIST_NO_METADATA));
-#if HAVE_CONST_VIR_DOMAIN_SNAPSHOT_LIST_INACTIVE
     rb_define_const(c_domain_snapshot, "LIST_INACTIVE",
                     INT2NUM(VIR_DOMAIN_SNAPSHOT_LIST_INACTIVE));
     rb_define_const(c_domain_snapshot, "LIST_ACTIVE",
@@ -5500,11 +5003,9 @@ void ruby_libvirt_domain_init(void)
                     INT2NUM(VIR_DOMAIN_SNAPSHOT_LIST_INTERNAL));
     rb_define_const(c_domain_snapshot, "LIST_EXTERNAL",
                     INT2NUM(VIR_DOMAIN_SNAPSHOT_LIST_EXTERNAL));
-#endif
     rb_define_method(c_domain, "list_all_snapshots",
                      libvirt_domain_list_all_snapshots, -1);
-#endif
-#if HAVE_CONST_VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE
+
     rb_define_const(c_domain_snapshot, "CREATE_REDEFINE",
                     INT2NUM(VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE));
     rb_define_const(c_domain_snapshot, "CREATE_CURRENT",
@@ -5515,125 +5016,64 @@ void ruby_libvirt_domain_init(void)
                     INT2NUM(VIR_DOMAIN_SNAPSHOT_CREATE_HALT));
     rb_define_const(c_domain_snapshot, "CREATE_DISK_ONLY",
                     INT2NUM(VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_SNAPSHOT_CREATE_REUSE_EXT
     rb_define_const(c_domain_snapshot, "CREATE_REUSE_EXT",
                     INT2NUM(VIR_DOMAIN_SNAPSHOT_CREATE_REUSE_EXT));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_SNAPSHOT_CREATE_QUIESCE
     rb_define_const(c_domain_snapshot, "CREATE_QUIESCE",
                     INT2NUM(VIR_DOMAIN_SNAPSHOT_CREATE_QUIESCE));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_SNAPSHOT_CREATE_ATOMIC
     rb_define_const(c_domain_snapshot, "CREATE_ATOMIC",
                     INT2NUM(VIR_DOMAIN_SNAPSHOT_CREATE_ATOMIC));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_SNAPSHOT_CREATE_LIVE
     rb_define_const(c_domain_snapshot, "CREATE_LIVE",
                     INT2NUM(VIR_DOMAIN_SNAPSHOT_CREATE_LIVE));
-#endif
-#if HAVE_VIRDOMAINSNAPSHOTNUMCHILDREN
     rb_define_method(c_domain_snapshot, "num_children",
                      libvirt_domain_snapshot_num_children, -1);
-#endif
-#if HAVE_VIRDOMAINSNAPSHOTLISTCHILDRENNAMES
     rb_define_method(c_domain_snapshot, "list_children_names",
                      libvirt_domain_snapshot_list_children_names, -1);
-#endif
-#if HAVE_VIRDOMAINSNAPSHOTLISTALLCHILDREN
     rb_define_method(c_domain_snapshot, "list_all_children",
                      libvirt_domain_snapshot_list_all_children, -1);
-#endif
-#if HAVE_VIRDOMAINSNAPSHOTGETPARENT
     rb_define_method(c_domain_snapshot, "parent",
                      libvirt_domain_snapshot_parent, -1);
-#endif
-#if HAVE_VIRDOMAINSNAPSHOTISCURRENT
     rb_define_method(c_domain_snapshot, "current?",
                      libvirt_domain_snapshot_current_p, -1);
-#endif
-#if HAVE_VIRDOMAINSNAPSHOTHASMETADATA
     rb_define_method(c_domain_snapshot, "has_metadata?",
                      libvirt_domain_snapshot_has_metadata_p, -1);
-#endif
-#if HAVE_VIRDOMAINSETMEMORYSTATSPERIOD
     rb_define_method(c_domain, "memory_stats_period=",
                      libvirt_domain_memory_stats_period, 1);
-#endif
-#if HAVE_VIRDOMAINFSTRIM
     rb_define_method(c_domain, "fstrim", libvirt_domain_fstrim, -1);
-#endif
-#if HAVE_CONST_VIR_DOMAIN_BLOCK_REBASE_SHALLOW
     rb_define_const(c_domain, "BLOCK_REBASE_SHALLOW",
                     INT2NUM(VIR_DOMAIN_BLOCK_REBASE_SHALLOW));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_BLOCK_REBASE_REUSE_EXT
     rb_define_const(c_domain, "BLOCK_REBASE_REUSE_EXT",
                     INT2NUM(VIR_DOMAIN_BLOCK_REBASE_REUSE_EXT));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_BLOCK_REBASE_COPY_RAW
     rb_define_const(c_domain, "BLOCK_REBASE_COPY_RAW",
                     INT2NUM(VIR_DOMAIN_BLOCK_REBASE_COPY_RAW));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_BLOCK_REBASE_COPY
     rb_define_const(c_domain, "BLOCK_REBASE_COPY",
                     INT2NUM(VIR_DOMAIN_BLOCK_REBASE_COPY));
-#endif
-#if HAVE_VIRDOMAINBLOCKREBASE
+
     rb_define_method(c_domain, "block_rebase", libvirt_domain_block_rebase, -1);
-#endif
-#if HAVE_CONST_VIR_DOMAIN_CHANNEL_FORCE
     rb_define_const(c_domain, "CHANNEL_FORCE",
                     INT2NUM(VIR_DOMAIN_CHANNEL_FORCE));
-#endif
-#if HAVE_VIRDOMAINOPENCHANNEL
     rb_define_method(c_domain, "open_channel", libvirt_domain_open_channel, -1);
-#endif
-#if HAVE_VIRDOMAINCREATEWITHFILES
     rb_define_method(c_domain, "create_with_files",
                      libvirt_domain_create_with_files, -1);
-#endif
-#if HAVE_VIRDOMAINOPENGRAPHICS
     rb_define_const(c_domain, "OPEN_GRAPHICS_SKIPAUTH",
                     INT2NUM(VIR_DOMAIN_OPEN_GRAPHICS_SKIPAUTH));
     rb_define_method(c_domain, "open_graphics",
                      libvirt_domain_open_graphics, -1);
-#endif
-#if HAVE_VIRDOMAINPMWAKEUP
     rb_define_method(c_domain, "pmwakeup", libvirt_domain_pmwakeup, -1);
-#endif
-#if HAVE_VIRDOMAINBLOCKRESIZE
     rb_define_method(c_domain, "block_resize", libvirt_domain_block_resize, -1);
-#endif
-#if HAVE_CONST_VIR_DOMAIN_BLOCK_RESIZE_BYTES
     rb_define_const(c_domain, "BLOCK_RESIZE_BYTES",
                     INT2NUM(VIR_DOMAIN_BLOCK_RESIZE_BYTES));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_SNAPSHOT_REVERT_RUNNING
     rb_define_const(c_domain_snapshot, "REVERT_RUNNING",
                     INT2NUM(VIR_DOMAIN_SNAPSHOT_REVERT_RUNNING));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED
     rb_define_const(c_domain_snapshot, "REVERT_PAUSED",
                     INT2NUM(VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_SNAPSHOT_REVERT_FORCE
     rb_define_const(c_domain_snapshot, "REVERT_FORCE",
                     INT2NUM(VIR_DOMAIN_SNAPSHOT_REVERT_FORCE));
-#endif
-#if HAVE_VIRDOMAINPMSUSPENDFORDURATION
     rb_define_method(c_domain, "pmsuspend_for_duration",
                      libvirt_domain_pmsuspend_for_duration, -1);
-#endif
-#if HAVE_VIRDOMAINMIGRATEGETCOMPRESSIONCACHE
     rb_define_method(c_domain, "migrate_compression_cache",
                      libvirt_domain_migrate_compression_cache, -1);
-#endif
-#if HAVE_VIRDOMAINMIGRATESETCOMPRESSIONCACHE
     rb_define_method(c_domain, "migrate_compression_cache=",
                      libvirt_domain_migrate_compression_cache_equal, 1);
-#endif
-#if HAVE_VIRDOMAINGETDISKERRORS
     rb_define_const(c_domain, "DISK_ERROR_NONE",
                     INT2NUM(VIR_DOMAIN_DISK_ERROR_NONE));
     rb_define_const(c_domain, "DISK_ERROR_UNSPEC",
@@ -5641,266 +5081,132 @@ void ruby_libvirt_domain_init(void)
     rb_define_const(c_domain, "DISK_ERROR_NO_SPACE",
                     INT2NUM(VIR_DOMAIN_DISK_ERROR_NO_SPACE));
     rb_define_method(c_domain, "disk_errors", libvirt_domain_disk_errors, -1);
-#endif
-#if HAVE_VIRDOMAINGETEMULATORPININFO
     rb_define_method(c_domain, "emulator_pin_info",
                      libvirt_domain_emulator_pin_info, -1);
-#endif
-#if HAVE_VIRDOMAINPINEMULATOR
     rb_define_method(c_domain, "pin_emulator", libvirt_domain_pin_emulator, -1);
-#endif
-#if HAVE_VIRDOMAINGETSECURITYLABELLIST
     rb_define_method(c_domain, "security_label_list",
                      libvirt_domain_security_label_list, 0);
-#endif
 
-#if HAVE_CONST_VIR_KEYCODE_SET_LINUX
     rb_define_const(c_domain, "KEYCODE_SET_LINUX",
                     INT2NUM(VIR_KEYCODE_SET_LINUX));
-#endif
-#if HAVE_CONST_VIR_KEYCODE_SET_XT
     rb_define_const(c_domain, "KEYCODE_SET_XT",
                     INT2NUM(VIR_KEYCODE_SET_XT));
-#endif
-#if HAVE_CONST_VIR_KEYCODE_SET_ATSET1
     rb_define_const(c_domain, "KEYCODE_SET_ATSET1",
                     INT2NUM(VIR_KEYCODE_SET_ATSET1));
-#endif
-#if HAVE_CONST_VIR_KEYCODE_SET_ATSET2
     rb_define_const(c_domain, "KEYCODE_SET_ATSET2",
                     INT2NUM(VIR_KEYCODE_SET_ATSET2));
-#endif
-#if HAVE_CONST_VIR_KEYCODE_SET_ATSET3
     rb_define_const(c_domain, "KEYCODE_SET_ATSET3",
                     INT2NUM(VIR_KEYCODE_SET_ATSET3));
-#endif
-#if HAVE_CONST_VIR_KEYCODE_SET_OSX
     rb_define_const(c_domain, "KEYCODE_SET_OSX",
                     INT2NUM(VIR_KEYCODE_SET_OSX));
-#endif
-#if HAVE_CONST_VIR_KEYCODE_SET_XT_KBD
     rb_define_const(c_domain, "KEYCODE_SET_XT_KBD",
                     INT2NUM(VIR_KEYCODE_SET_XT_KBD));
-#endif
-#if HAVE_CONST_VIR_KEYCODE_SET_USB
     rb_define_const(c_domain, "KEYCODE_SET_USB",
                     INT2NUM(VIR_KEYCODE_SET_USB));
-#endif
-#if HAVE_CONST_VIR_KEYCODE_SET_WIN32
     rb_define_const(c_domain, "KEYCODE_SET_WIN32",
                     INT2NUM(VIR_KEYCODE_SET_WIN32));
-#endif
-#if HAVE_CONST_VIR_KEYCODE_SET_RFB
     rb_define_const(c_domain, "KEYCODE_SET_RFB", INT2NUM(VIR_KEYCODE_SET_RFB));
-#endif
-#if HAVE_VIRDOMAINGETJOBSTATS
+
     rb_define_method(c_domain, "job_stats", libvirt_domain_job_stats, -1);
-#endif
-#if HAVE_VIRDOMAINGETBLOCKIOTUNE
     rb_define_method(c_domain, "block_iotune",
                      libvirt_domain_block_iotune, -1);
-#endif
-#if HAVE_VIRDOMAINSETBLOCKIOTUNE
     rb_define_method(c_domain, "block_iotune=",
                      libvirt_domain_block_iotune_equal, 1);
-#endif
-#if HAVE_VIRDOMAINBLOCKCOMMIT
     rb_define_method(c_domain, "block_commit", libvirt_domain_block_commit, -1);
-#endif
-#if HAVE_VIRDOMAINBLOCKPULL
     rb_define_method(c_domain, "block_pull", libvirt_domain_block_pull, -1);
-#endif
-#if HAVE_VIRDOMAINBLOCKJOBSETSPEED
     rb_define_method(c_domain, "block_job_speed=",
                      libvirt_domain_block_job_speed_equal, 1);
-#endif
-#if HAVE_CONST_VIR_DOMAIN_BLOCK_JOB_SPEED_BANDWIDTH_BYTES
     rb_define_const(c_domain, "BLOCK_JOB_SPEED_BANDWIDTH_BYTES",
                     INT2NUM(VIR_DOMAIN_BLOCK_JOB_SPEED_BANDWIDTH_BYTES));
-#endif
-#if HAVE_VIRDOMAINGETBLOCKJOBINFO
     rb_define_method(c_domain, "block_job_info", libvirt_domain_block_job_info,
                      -1);
-#endif
-#if HAVE_CONST_VIR_DOMAIN_BLOCK_JOB_INFO_BANDWIDTH_BYTES
     rb_define_const(c_domain, "BLOCK_JOB_INFO_BANDWIDTH_BYTES",
                     INT2NUM(VIR_DOMAIN_BLOCK_JOB_INFO_BANDWIDTH_BYTES));
-#endif
 
-#if HAVE_VIRDOMAINBLOCKJOBABORT
     rb_define_method(c_domain, "block_job_abort",
                      libvirt_domain_block_job_abort, -1);
-#endif
-#if HAVE_VIRDOMAINGETINTERFACEPARAMETERS
     rb_define_method(c_domain, "interface_parameters",
                      libvirt_domain_interface_parameters, -1);
     rb_define_method(c_domain, "interface_parameters=",
                      libvirt_domain_interface_parameters_equal, 1);
-#endif
-#if HAVE_VIRDOMAINBLOCKSTATSFLAGS
     rb_define_method(c_domain, "block_stats_flags",
                      libvirt_domain_block_stats_flags, -1);
-#endif
-#if HAVE_VIRDOMAINGETNUMAPARAMETERS
     rb_define_method(c_domain, "numa_parameters",
                      libvirt_domain_numa_parameters, -1);
     rb_define_method(c_domain, "numa_parameters=",
                      libvirt_domain_numa_parameters_equal, 1);
-#endif
-#if HAVE_VIRDOMAINLXCOPENNAMESPACE
     rb_define_method(c_domain, "lxc_open_namespace",
                      libvirt_domain_lxc_open_namespace, -1);
-#endif
-#if HAVE_VIRDOMAINQEMUAGENTCOMMAND
     rb_define_method(c_domain, "qemu_agent_command",
                      libvirt_domain_qemu_agent_command, -1);
-#endif
-#if HAVE_CONST_VIR_DOMAIN_QEMU_AGENT_COMMAND_BLOCK
     rb_define_const(c_domain, "QEMU_AGENT_COMMAND_BLOCK",
                     INT2NUM(VIR_DOMAIN_QEMU_AGENT_COMMAND_BLOCK));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_QEMU_AGENT_COMMAND_DEFAULT
     rb_define_const(c_domain, "QEMU_AGENT_COMMAND_DEFAULT",
                     INT2NUM(VIR_DOMAIN_QEMU_AGENT_COMMAND_DEFAULT));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_QEMU_AGENT_COMMAND_NOWAIT
     rb_define_const(c_domain, "QEMU_AGENT_COMMAND_NOWAIT",
                     INT2NUM(VIR_DOMAIN_QEMU_AGENT_COMMAND_NOWAIT));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_QEMU_AGENT_COMMAND_SHUTDOWN
     rb_define_const(c_domain, "QEMU_AGENT_COMMAND_SHUTDOWN",
                     INT2NUM(VIR_DOMAIN_QEMU_AGENT_COMMAND_SHUTDOWN));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_QEMU_MONITOR_COMMAND_DEFAULT
     rb_define_const(c_domain, "QEMU_MONITOR_COMMAND_DEFAULT",
                     INT2NUM(VIR_DOMAIN_QEMU_MONITOR_COMMAND_DEFAULT));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_QEMU_MONITOR_COMMAND_HMP
     rb_define_const(c_domain, "QEMU_MONITOR_COMMAND_HMP",
                     INT2NUM(VIR_DOMAIN_QEMU_MONITOR_COMMAND_HMP));
-#endif
-#if HAVE_VIRDOMAINLXCENTERNAMESPACE
     rb_define_method(c_domain, "lxc_enter_namespace",
                      libvirt_domain_lxc_enter_namespace, -1);
-#endif
-#if HAVE_VIRDOMAINMIGRATE3
     rb_define_method(c_domain, "migrate3", libvirt_domain_migrate3, -1);
     rb_define_method(c_domain, "migrate_to_uri3",
                      libvirt_domain_migrate_to_uri3, -1);
-#endif
-#if HAVE_CONST_VIR_DOMAIN_BLOCK_COMMIT_SHALLOW
     rb_define_const(c_domain, "BLOCK_COMMIT_SHALLOW",
                     INT2NUM(VIR_DOMAIN_BLOCK_COMMIT_SHALLOW));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_BLOCK_COMMIT_DELETE
     rb_define_const(c_domain, "BLOCK_COMMIT_DELETE",
                     INT2NUM(VIR_DOMAIN_BLOCK_COMMIT_DELETE));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_BLOCK_COMMIT_ACTIVE
     rb_define_const(c_domain, "BLOCK_COMMIT_ACTIVE",
                     INT2NUM(VIR_DOMAIN_BLOCK_COMMIT_ACTIVE));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_BLOCK_COMMIT_RELATIVE
     rb_define_const(c_domain, "BLOCK_COMMIT_RELATIVE",
                     INT2NUM(VIR_DOMAIN_BLOCK_COMMIT_RELATIVE));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_BLOCK_COMMIT_BANDWIDTH_BYTES
     rb_define_const(c_domain, "BLOCK_COMMIT_BANDWIDTH_BYTES",
                     INT2NUM(VIR_DOMAIN_BLOCK_COMMIT_BANDWIDTH_BYTES));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_BLOCK_JOB_TYPE_UNKNOWN
     rb_define_const(c_domain, "BLOCK_JOB_TYPE_UNKNOWN",
                     INT2NUM(VIR_DOMAIN_BLOCK_JOB_TYPE_UNKNOWN));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_BLOCK_JOB_TYPE_PULL
     rb_define_const(c_domain, "BLOCK_JOB_TYPE_PULL",
                     INT2NUM(VIR_DOMAIN_BLOCK_JOB_TYPE_PULL));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_BLOCK_JOB_TYPE_COPY
     rb_define_const(c_domain, "BLOCK_JOB_TYPE_COPY",
                     INT2NUM(VIR_DOMAIN_BLOCK_JOB_TYPE_COPY));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_BLOCK_JOB_TYPE_COMMIT
     rb_define_const(c_domain, "BLOCK_JOB_TYPE_COMMIT",
                     INT2NUM(VIR_DOMAIN_BLOCK_JOB_TYPE_COMMIT));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_BLOCK_JOB_TYPE_ACTIVE_COMMIT
     rb_define_const(c_domain, "BLOCK_JOB_TYPE_ACTIVE_COMMIT",
                     INT2NUM(VIR_DOMAIN_BLOCK_JOB_TYPE_ACTIVE_COMMIT));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_BLOCK_JOB_ABORT_ASYNC
     rb_define_const(c_domain, "BLOCK_JOB_ABORT_ASYNC",
                     INT2NUM(VIR_DOMAIN_BLOCK_JOB_ABORT_ASYNC));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_BLOCK_JOB_ABORT_PIVOT
     rb_define_const(c_domain, "BLOCK_JOB_ABORT_PIVOT",
                     INT2NUM(VIR_DOMAIN_BLOCK_JOB_ABORT_PIVOT));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_BLOCK_JOB_COMPLETED
     rb_define_const(c_domain, "BLOCK_JOB_COMPLETED",
                     INT2NUM(VIR_DOMAIN_BLOCK_JOB_COMPLETED));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_BLOCK_JOB_FAILED
     rb_define_const(c_domain, "BLOCK_JOB_FAILED",
                     INT2NUM(VIR_DOMAIN_BLOCK_JOB_FAILED));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_BLOCK_JOB_CANCELED
     rb_define_const(c_domain, "BLOCK_JOB_CANCELED",
                     INT2NUM(VIR_DOMAIN_BLOCK_JOB_CANCELED));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_BLOCK_JOB_READY
     rb_define_const(c_domain, "BLOCK_JOB_READY",
                     INT2NUM(VIR_DOMAIN_BLOCK_JOB_READY));
-#endif
-#if HAVE_VIRDOMAINGETCPUSTATS
     rb_define_method(c_domain, "cpu_stats", libvirt_domain_cpu_stats, -1);
-#endif
-#if HAVE_CONST_VIR_DOMAIN_CORE_DUMP_FORMAT_RAW
     rb_define_const(c_domain, "CORE_DUMP_FORMAT_RAW",
                     INT2NUM(VIR_DOMAIN_CORE_DUMP_FORMAT_RAW));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_ZLIB
     rb_define_const(c_domain, "CORE_DUMP_FORMAT_KDUMP_ZLIB",
                     INT2NUM(VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_ZLIB));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_LZO
     rb_define_const(c_domain, "CORE_DUMP_FORMAT_KDUMP_LZO",
                     INT2NUM(VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_LZO));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_SNAPPY
     rb_define_const(c_domain, "CORE_DUMP_FORMAT_KDUMP_SNAPPY",
                     INT2NUM(VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_SNAPPY));
-#endif
-#if HAVE_VIRDOMAINGETTIME
     rb_define_method(c_domain, "time", libvirt_domain_get_time, -1);
-#endif
-#if HAVE_VIRDOMAINSETTIME
     rb_define_method(c_domain, "time=", libvirt_domain_time_equal, 1);
-#endif
-#if HAVE_VIRDOMAINCOREDUMPWITHFORMAT
     rb_define_method(c_domain, "core_dump_with_format",
                      libvirt_domain_core_dump_with_format, -1);
-#endif
-#if HAVE_VIRDOMAINFSFREEZE
     rb_define_method(c_domain, "fs_freeze", libvirt_domain_fs_freeze, -1);
-#endif
-#if HAVE_VIRDOMAINFSTHAW
     rb_define_method(c_domain, "fs_thaw", libvirt_domain_fs_thaw, -1);
-#endif
-#if HAVE_VIRDOMAINGETFSINFO
     rb_define_method(c_domain, "fs_info", libvirt_domain_fs_info, -1);
-#endif
-#if HAVE_VIRDOMAINRENAME
     rb_define_method(c_domain, "rename", libvirt_domain_rename, -1);
-#endif
-#if HAVE_VIRDOMAINSETUSERPASSWORD
     rb_define_method(c_domain, "user_password=", libvirt_domain_user_password_equal, 1);
-#endif
-#if HAVE_CONST_VIR_DOMAIN_PASSWORD_ENCRYPTED
     rb_define_const(c_domain, "PASSWORD_ENCRYPTED",
                     INT2NUM(VIR_DOMAIN_PASSWORD_ENCRYPTED));
-#endif
-#if HAVE_CONST_VIR_DOMAIN_TIME_SYNC
     rb_define_const(c_domain, "TIME_SYNC", INT2NUM(VIR_DOMAIN_TIME_SYNC));
-#endif
 }