ruby-libvirt 0.4.0 → 0.5.0

data/ext/libvirt/common.h

@@ -2,27 +2,30 @@
 #define COMMON_H
 
 /* Macros to ease some of the boilerplate */
-VALUE generic_new(VALUE klass, void *ptr, VALUE conn,
-                  RUBY_DATA_FUNC free_func);
+VALUE ruby_libvirt_new_class(VALUE klass, void *ptr, VALUE conn,
+                             RUBY_DATA_FUNC free_func);
 
-#define generic_get(kind, v)                                            \
+#define ruby_libvirt_get_struct(kind, v)                                \
     do {                                                                \
         vir##kind##Ptr ptr;                                             \
         Data_Get_Struct(v, vir##kind, ptr);                             \
-        if (!ptr)                                                       \
+        if (!ptr) {                                                     \
             rb_raise(rb_eArgError, #kind " has been freed");            \
+        }                                                               \
         return ptr;                                                     \
     } while (0);
 
-#define generic_free(kind, p)                                           \
+#define ruby_libvirt_free_struct(kind, p)                               \
     do {                                                                \
         int r;                                                          \
         r = vir##kind##Free((vir##kind##Ptr) p);                        \
-        if (r < 0)                                                      \
+        if (r < 0) {                                                    \
             rb_raise(rb_eSystemCallError, # kind " free failed");       \
+        }                                                               \
     } while(0);
 
-VALUE create_error(VALUE error, const char* method, virConnectPtr conn);
+void ruby_libvirt_raise_error_if(const int condition, VALUE error,
+                                 const char *method, virConnectPtr conn);
 
 /*
  * Code generating macros.
@@ -35,30 +38,37 @@ VALUE create_error(VALUE error, const char* method, virConnectPtr conn);
  * function will return the string on success and throw an exception on
  * error. The string returned by FUNC is freed if dealloc is true.
  */
-#define gen_call_string(func, conn, dealloc, args...)                   \
-    do {                                                                \
-        const char *str;                                                \
-        VALUE result;                                                   \
-                                                                        \
-        str = func(args);                                               \
-        _E(str == NULL, create_error(e_Error, # func, conn));           \
-                                                                        \
-        result = rb_str_new2(str);                                      \
-        if (dealloc)                                                    \
-            xfree((void *) str);                                        \
-        return result;                                                  \
+#define ruby_libvirt_generate_call_string(func, conn, dealloc, args...)  \
+    do {                                                                 \
+        const char *str;                                                 \
+        VALUE result;                                                    \
+        int exception;                                                   \
+                                                                         \
+        str = func(args);                                                \
+        ruby_libvirt_raise_error_if(str == NULL, e_Error, # func, conn); \
+        if (dealloc) {                                                   \
+            result = rb_protect(ruby_libvirt_str_new2_wrap, (VALUE)&str, &exception); \
+            xfree((void *) str);                                         \
+            if (exception) {                                             \
+                rb_jump_tag(exception);                                  \
+            }                                                            \
+        }                                                                \
+        else {                                                           \
+            result = rb_str_new2(str);                                   \
+        }                                                                \
+        return result;                                                   \
     } while(0)
 
 /* Generate a call to vir##KIND##Free and return Qnil. Set the the embedded
  * vir##KIND##Ptr to NULL. If that pointer is already NULL, do nothing.
  */
-#define gen_call_free(kind, s)                                          \
+#define ruby_libvirt_generate_call_free(kind, s)                        \
     do {                                                                \
         vir##kind##Ptr ptr;                                             \
         Data_Get_Struct(s, vir##kind, ptr);                             \
         if (ptr != NULL) {                                              \
             int r = vir##kind##Free(ptr);                               \
-            _E(r < 0, create_error(e_Error, "vir" #kind "Free", conn(s))); \
+            ruby_libvirt_raise_error_if(r < 0, e_Error, "vir" #kind "Free", ruby_libvirt_connect_get(s)); \
             DATA_PTR(s) = NULL;                                         \
         }                                                               \
         return Qnil;                                                    \
@@ -68,89 +78,89 @@ VALUE create_error(VALUE error, const char* method, virConnectPtr conn);
  * indicates error and 0 success. The Ruby function will return Qnil on
  * success and throw an exception on error.
  */
-#define gen_call_void(func, conn, args...)                              \
-    do {                                                                \
-        int _r_##func;                                                  \
-        _r_##func = func(args);                                         \
-        _E(_r_##func < 0, create_error(e_Error, #func, conn));          \
-        return Qnil;                                                    \
-    } while(0)
-
-/*
- * Generate a call to a virConnectNumOf... function. C is the Ruby VALUE
- * holding the connection and OBJS is a token indicating what objects to
- * get the number of, e.g. 'Domains'
- */
-#define gen_conn_num_of(c, objs)                                        \
-    do {                                                                \
-        int result;                                                     \
-        virConnectPtr conn = connect_get(c);                            \
-                                                                        \
-        result = virConnectNumOf##objs(conn);                           \
-        _E(result < 0, create_error(e_RetrieveError, "virConnectNumOf" # objs, conn));                \
-                                                                        \
-        return INT2NUM(result);                                         \
-    } while(0)
-
-
-VALUE gen_list(int num, char ***list);
-
-/*
- * Generate a call to a virConnectList... function. S is the Ruby VALUE
- * holding the connection and OBJS is a token indicating what objects to
- * get the number of, e.g. 'Domains' The list function must return an array
- * of strings, which is returned as a Ruby array
- */
-#define gen_conn_list_names(s, objs)                                    \
-    do {                                                                \
-        int r, num;                                                     \
-        char **names;                                                   \
-        virConnectPtr conn = connect_get(s);                            \
-                                                                        \
-        num = virConnectNumOf##objs(conn);                              \
-        _E(num < 0, create_error(e_RetrieveError, "virConnectNumOf" # objs, conn));   \
-        if (num == 0) {                                                 \
-            /* if num is 0, don't call virConnectList* function */      \
-            return rb_ary_new2(num);                                    \
-        }                                                               \
-        names = ALLOC_N(char *, num);                                   \
-        r = virConnectList##objs(conn, names, num);                     \
-        if (r < 0) {                                                    \
-            xfree(names);                                               \
-            _E(r < 0, create_error(e_RetrieveError, "virConnectList" # objs, conn));  \
-        }                                                               \
-                                                                        \
-        return gen_list(num, &names);                                   \
+#define ruby_libvirt_generate_call_nil(func, conn, args...)               \
+    do {                                                                  \
+        int _r_##func;                                                    \
+        _r_##func = func(args);                                           \
+        ruby_libvirt_raise_error_if(_r_##func < 0, e_Error, #func, conn); \
+        return Qnil;                                                      \
     } while(0)
 
 /* Generate a call to a function FUNC which returns an int; -1 indicates
  * error, 0 indicates Qfalse, and 1 indicates Qtrue.
  */
-#define gen_call_truefalse(func, conn, args...)                         \
-    do {                                                                \
-        int _r_##func;                                                  \
-        _r_##func = func(args);                                         \
-        _E(_r_##func < 0, create_error(e_Error, #func, conn));          \
-        return _r_##func ? Qtrue : Qfalse;                              \
+#define ruby_libvirt_generate_call_truefalse(func, conn, args...)         \
+    do {                                                                  \
+        int _r_##func;                                                    \
+        _r_##func = func(args);                                           \
+        ruby_libvirt_raise_error_if(_r_##func < 0, e_Error, #func, conn); \
+        return _r_##func ? Qtrue : Qfalse;                                \
     } while(0)
 
 /* Generate a call to a function FUNC which returns an int error, where -1
  * indicates error and >= 0 success. The Ruby function will return the integer
  * success and throw an exception on error.
  */
-#define gen_call_int(func, conn, args...)                               \
+#define ruby_libvirt_generate_call_int(func, conn, args...)             \
     do {                                                                \
         int _r_##func;                                                  \
         _r_##func = func(args);                                         \
-        _E(_r_##func < 0, create_error(e_RetrieveError, #func, conn));  \
+        ruby_libvirt_raise_error_if(_r_##func < 0, e_RetrieveError, #func, conn); \
         return INT2NUM(_r_##func);                                      \
     } while(0)
 
-/* Error handling */
-#define _E(cond, excep) \
-    do { if (cond) rb_exc_raise(excep); } while(0)
+#define ruby_libvirt_generate_uuid(func, conn, obj)                     \
+    do {                                                                \
+        char uuid[VIR_UUID_STRING_BUFLEN];                              \
+        int _r_##func;                                                  \
+        _r_##func = func(obj, uuid);                                    \
+        ruby_libvirt_raise_error_if(_r_##func < 0, e_RetrieveError, #func, conn); \
+        return rb_str_new2((char *) uuid);                              \
+    } while (0)
 
-int is_symbol_or_proc(VALUE handle);
+
+#define ruby_libvirt_generate_call_list_all(type, argc, argv, listfunc, object, val, newfunc, freefunc) \
+    do {                                                                \
+        VALUE flags;                                                    \
+        type *list;                                                     \
+        size_t i;                                                       \
+        int ret;                                                        \
+        VALUE result;                                                   \
+        int exception = 0;                                              \
+        struct ruby_libvirt_ary_push_arg arg;                           \
+                                                                        \
+        rb_scan_args(argc, argv, "01", &flags);                         \
+        ret = listfunc(object, &list, ruby_libvirt_value_to_uint(flags)); \
+        ruby_libvirt_raise_error_if(ret < 0, e_RetrieveError, #listfunc, ruby_libvirt_connect_get(val)); \
+        result = rb_protect(ruby_libvirt_ary_new2_wrap, (VALUE)&ret, &exception); \
+        if (exception) {                                                \
+            goto exception;                                             \
+        }                                                               \
+        for (i = 0; i < ret; i++) {                                     \
+            arg.arr = result;                                           \
+            arg.value = newfunc(list[i], val);                          \
+            rb_protect(ruby_libvirt_ary_push_wrap, (VALUE)&arg, &exception); \
+            if (exception) {                                            \
+                goto exception;                                         \
+            }                                                           \
+        }                                                               \
+                                                                        \
+        free(list);                                                     \
+                                                                        \
+        return result;                                                  \
+                                                                        \
+    exception:                                                          \
+        for (i = 0; i < ret; i++) {                                     \
+            freefunc(list[i]);                                          \
+        }                                                               \
+        free(list);                                                     \
+        rb_jump_tag(exception);                                         \
+                                                                        \
+        /* not needed, but here to shut the compiler up */              \
+        return Qnil;                                                    \
+    } while(0)
+
+int ruby_libvirt_is_symbol_or_proc(VALUE handle);
 
 extern VALUE e_RetrieveError;
 extern VALUE e_Error;
@@ -159,42 +169,90 @@ extern VALUE e_NoSupportError;
 
 extern VALUE m_libvirt;
 
-char *get_string_or_nil(VALUE arg);
+char *ruby_libvirt_get_cstring_or_null(VALUE arg);
 
-struct rb_ary_entry_arg {
-    VALUE arr;
-    int elem;
+VALUE ruby_libvirt_generate_list(int num, char **list);
+
+VALUE ruby_libvirt_get_parameters(VALUE d, unsigned int flags, void *opaque,
+                                  unsigned int typesize,
+                                  char *(*nparams_cb)(VALUE d,
+                                                      unsigned int flags,
+                                                      void *opaque,
+                                                      int *nparams),
+                                  char *(*get_cb)(VALUE d, unsigned int flags,
+                                                  void *voidparams,
+                                                  int *nparams, void *opaque),
+                                  void (*hash_set)(void *voidparams, int i,
+                                                   VALUE result));
+VALUE ruby_libvirt_get_typed_parameters(VALUE d, unsigned int flags,
+                                        void *opaque,
+                                        char *(*nparams_cb)(VALUE d,
+                                                            unsigned int flags,
+                                                            void *opaque,
+                                                            int *nparams),
+                                        char *(*get_cb)(VALUE d,
+                                                        unsigned int flags,
+                                                        void *params,
+                                                        int *nparams,
+                                                        void *opaque));
+struct ruby_libvirt_typed_param {
+    char *name;
+    int type;
 };
-VALUE rb_ary_entry_wrap(VALUE arg);
-VALUE rb_ary_new_wrap(VALUE arg);
-struct rb_ary_push_arg {
+struct ruby_libvirt_parameter_assign_args {
+    struct ruby_libvirt_typed_param *allowed;
+    unsigned int num_allowed;
+
+    virTypedParameter *params;
+    int i;
+};
+int ruby_libvirt_typed_parameter_assign(VALUE key, VALUE val, VALUE in);
+VALUE ruby_libvirt_set_typed_parameters(VALUE d, VALUE input,
+                                        unsigned int flags, void *opaque,
+                                        struct ruby_libvirt_typed_param *allowed,
+                                        unsigned int num_allowed,
+                                        char *(*set_cb)(VALUE d,
+                                                        unsigned int flags,
+                                                        virTypedParameterPtr params,
+                                                        int nparams,
+                                                        void *opaque));
+
+int ruby_libvirt_get_maxcpus(virConnectPtr conn);
+
+void ruby_libvirt_typed_params_to_hash(void *voidparams, int i, VALUE hash);
+void ruby_libvirt_assign_hash_and_flags(VALUE in, VALUE *hash, VALUE *flags);
+
+unsigned int ruby_libvirt_value_to_uint(VALUE in);
+int ruby_libvirt_value_to_int(VALUE in);
+unsigned long ruby_libvirt_value_to_ulong(VALUE in);
+unsigned long long ruby_libvirt_value_to_ulonglong(VALUE in);
+
+VALUE ruby_libvirt_ary_new2_wrap(VALUE arg);
+struct ruby_libvirt_ary_push_arg {
     VALUE arr;
     VALUE value;
 };
-VALUE rb_ary_push_wrap(VALUE arg);
-VALUE rb_ary_new2_wrap(VALUE arg);
+VALUE ruby_libvirt_ary_push_wrap(VALUE arg);
+struct ruby_libvirt_ary_store_arg {
+    VALUE arr;
+    long index;
+    VALUE elem;
+};
+VALUE ruby_libvirt_ary_store_wrap(VALUE arg);
 
-VALUE rb_str_new2_wrap(VALUE arg);
-struct rb_str_new_arg {
+VALUE ruby_libvirt_str_new2_wrap(VALUE arg);
+struct ruby_libvirt_str_new_arg {
     char *val;
     size_t size;
 };
-VALUE rb_str_new_wrap(VALUE arg);
-VALUE rb_string_value_cstr_wrap(VALUE arg);
+VALUE ruby_libvirt_str_new_wrap(VALUE arg);
 
-struct rb_iv_set_arg {
-    VALUE klass;
-    char *member;
-    VALUE value;
-};
-VALUE rb_iv_set_wrap(VALUE arg);
-
-struct rb_class_new_instance_arg {
-    int argc;
-    VALUE *argv;
-    VALUE klass;
+struct ruby_libvirt_hash_aset_arg {
+    VALUE hash;
+    char *name;
+    VALUE val;
 };
-VALUE rb_class_new_instance_wrap(VALUE arg);
+VALUE ruby_libvirt_hash_aset_wrap(VALUE arg);
 
 #ifndef RARRAY_LEN
 #define RARRAY_LEN(ar) (RARRAY(ar)->len)
@@ -208,4 +266,6 @@ VALUE rb_class_new_instance_wrap(VALUE arg);
 #define RSTRING_LEN(str) (RSTRING(str)->len)
 #endif
 
+#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
+
 #endif

data/ext/libvirt/connect.c

@@ -2,6 +2,7 @@
  * connect.c: virConnect methods
  *
  * Copyright (C) 2007,2010 Red Hat Inc.
+ * Copyright (C) 2013 Chris Lalancette <clalancette@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -20,66 +21,108 @@
 
 #include <ruby.h>
 #include <libvirt/libvirt.h>
+#if HAVE_VIRDOMAINQEMUATTACH
+#include <libvirt/libvirt-qemu.h>
+#endif
 #include <libvirt/virterror.h>
 #include "extconf.h"
 #include "common.h"
 #include "domain.h"
 #include "network.h"
+#include "interface.h"
+#include "nodedevice.h"
+#include "nwfilter.h"
+#include "secret.h"
+#include "stream.h"
+
+/*
+ * Generate a call to a virConnectNumOf... function. C is the Ruby VALUE
+ * holding the connection and OBJS is a token indicating what objects to
+ * get the number of, e.g. 'Domains'
+ */
+#define gen_conn_num_of(c, objs)                                        \
+    do {                                                                \
+        int r;                                                          \
+        r = virConnectNumOf##objs(ruby_libvirt_connect_get(c));         \
+        ruby_libvirt_raise_error_if(r < 0, e_RetrieveError, "virConnectNumOf" # objs, ruby_libvirt_connect_get(c)); \
+        return INT2NUM(r);                                              \
+    } while(0)
+
+/*
+ * Generate a call to a virConnectList... function. C is the Ruby VALUE
+ * holding the connection and OBJS is a token indicating what objects to
+ * get the number of, e.g. 'Domains' The list function must return an array
+ * of strings, which is returned as a Ruby array
+ */
+#define gen_conn_list_names(c, objs)                                    \
+    do {                                                                \
+        int r, num;                                                     \
+        char **names;                                                   \
+        num = virConnectNumOf##objs(ruby_libvirt_connect_get(c));       \
+        ruby_libvirt_raise_error_if(num < 0, e_RetrieveError, "virConnectNumOf" # objs, ruby_libvirt_connect_get(c)); \
+        if (num == 0) {                                                 \
+            /* if num is 0, don't call virConnectList* function */      \
+            return rb_ary_new2(num);                                    \
+        }                                                               \
+        names = alloca(sizeof(char *) * num);                           \
+        r = virConnectList##objs(ruby_libvirt_connect_get(c), names, num); \
+        ruby_libvirt_raise_error_if(r < 0, e_RetrieveError, "virConnectList" # objs, ruby_libvirt_connect_get(c)); \
+        return ruby_libvirt_generate_list(num, names);                  \
+    } while(0)
 
 static VALUE c_connect;
-static VALUE c_node_security_model;
+VALUE c_node_security_model;
 static VALUE c_node_info;
 
-static void connect_close(void *p) {
+static void connect_close(void *c)
+{
     int r;
 
-    if (!p)
+    if (!c) {
         return;
-    r = virConnectClose((virConnectPtr) p);
-    _E(r < 0, create_error(rb_eSystemCallError, "virConnectClose", p));
-}
-
-VALUE connect_new(virConnectPtr p) {
-    return Data_Wrap_Struct(c_connect, NULL, connect_close, p);
+    }
+    r = virConnectClose((virConnectPtr) c);
+    ruby_libvirt_raise_error_if(r < 0, rb_eSystemCallError, "virConnectClose",
+                                c);
 }
 
-virConnectPtr connect_get(VALUE s) {
-    generic_get(Connect, s);
+VALUE ruby_libvirt_connect_new(virConnectPtr c)
+{
+    return Data_Wrap_Struct(c_connect, NULL, connect_close, c);
 }
 
-VALUE conn_attr(VALUE s) {
-    if (rb_obj_is_instance_of(s, c_connect) != Qtrue) {
-        s = rb_iv_get(s, "@connection");
+VALUE ruby_libvirt_conn_attr(VALUE c)
+{
+    if (rb_obj_is_instance_of(c, c_connect) != Qtrue) {
+        c = rb_iv_get(c, "@connection");
     }
-    if (rb_obj_is_instance_of(s, c_connect) != Qtrue) {
+    if (rb_obj_is_instance_of(c, c_connect) != Qtrue) {
         rb_raise(rb_eArgError, "Expected Connection object");
     }
-    return s;
+    return c;
 }
 
-virConnectPtr conn(VALUE s) {
-    virConnectPtr conn;
-
-    s = conn_attr(s);
-    Data_Get_Struct(s, virConnect, conn);
-    if (!conn)
-        rb_raise(rb_eArgError, "Connection has been closed");
-    return conn;
+virConnectPtr ruby_libvirt_connect_get(VALUE c)
+{
+    c = ruby_libvirt_conn_attr(c);
+    ruby_libvirt_get_struct(Connect, c);
 }
 
 /*
  * call-seq:
  *   conn.close -> nil
  *
- * Call +virConnectClose+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectClose]
+ * Call virConnectClose[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectClose]
  * to close the connection.
  */
-static VALUE libvirt_conn_close(VALUE s) {
+static VALUE libvirt_connect_close(VALUE c)
+{
     virConnectPtr conn;
-    Data_Get_Struct(s, virConnect, conn);
+
+    Data_Get_Struct(c, virConnect, conn);
     if (conn) {
         connect_close(conn);
-        DATA_PTR(s) = NULL;
+        DATA_PTR(c) = NULL;
     }
     return Qnil;
 }
@@ -90,38 +133,43 @@ static VALUE libvirt_conn_close(VALUE s) {
  *
  * Return +true+ if the connection is closed, +false+ if it is open.
  */
-static VALUE libvirt_conn_closed_p(VALUE s) {
+static VALUE libvirt_connect_closed_p(VALUE c)
+{
     virConnectPtr conn;
 
-    Data_Get_Struct(s, virConnect, conn);
-    return (conn==NULL) ? Qtrue : Qfalse;
+    Data_Get_Struct(c, virConnect, conn);
+    return (conn == NULL) ? Qtrue : Qfalse;
 }
 
 /*
  * call-seq:
  *   conn.type -> string
  *
- * Call +virConnectGetType+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectGetType]
+ * Call virConnectGetType[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectGetType]
  * to retrieve the type of hypervisor for this connection.
  */
-static VALUE libvirt_conn_type(VALUE s) {
-    gen_call_string(virConnectGetType, conn(s), 0, connect_get(s));
+static VALUE libvirt_connect_type(VALUE c)
+{
+    ruby_libvirt_generate_call_string(virConnectGetType,
+                                      ruby_libvirt_connect_get(c), 0,
+                                      ruby_libvirt_connect_get(c));
 }
 
 /*
  * call-seq:
  *   conn.version -> fixnum
  *
- * Call +virConnectGetVersion+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectGetVersion]
+ * Call virConnectGetVersion[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectGetVersion]
  * to retrieve the version of the hypervisor for this connection.
  */
-static VALUE libvirt_conn_version(VALUE s) {
+static VALUE libvirt_connect_version(VALUE c)
+{
     int r;
     unsigned long v;
-    virConnectPtr conn = connect_get(s);
 
-    r = virConnectGetVersion(conn, &v);
-    _E(r < 0, create_error(e_RetrieveError, "virConnectGetVersion", conn));
+    r = virConnectGetVersion(ruby_libvirt_connect_get(c), &v);
+    ruby_libvirt_raise_error_if(r < 0, e_RetrieveError, "virConnectGetVersion",
+                                ruby_libvirt_connect_get(c));
 
     return ULONG2NUM(v);
 }
@@ -131,16 +179,18 @@ static VALUE libvirt_conn_version(VALUE s) {
  * call-seq:
  *   conn.libversion -> fixnum
  *
- * Call +virConnectGetLibVersion+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectGetLibVersion]
+ * Call virConnectGetLibVersion[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectGetLibVersion]
  * to retrieve the version of the libvirt library for this connection.
  */
-static VALUE libvirt_conn_libversion(VALUE s) {
+static VALUE libvirt_connect_libversion(VALUE c)
+{
     int r;
     unsigned long v;
-    virConnectPtr conn = connect_get(s);
 
-    r = virConnectGetLibVersion(conn, &v);
-    _E(r < 0, create_error(e_RetrieveError, "virConnectGetLibVersion", conn));
+    r = virConnectGetLibVersion(ruby_libvirt_connect_get(c), &v);
+    ruby_libvirt_raise_error_if(r < 0, e_RetrieveError,
+                                "virConnectGetLibVersion",
+                                ruby_libvirt_connect_get(c));
 
     return ULONG2NUM(v);
 }
@@ -150,56 +200,66 @@ static VALUE libvirt_conn_libversion(VALUE s) {
  * call-seq:
  *   conn.hostname -> string
  *
- * Call +virConnectGetHostname+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectGetHostname]
+ * Call virConnectGetHostname[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectGetHostname]
  * to retrieve the hostname of the hypervisor for this connection.
  */
-static VALUE libvirt_conn_hostname(VALUE s) {
-    gen_call_string(virConnectGetHostname, conn(s), 1, connect_get(s));
+static VALUE libvirt_connect_hostname(VALUE c)
+{
+    ruby_libvirt_generate_call_string(virConnectGetHostname,
+                                      ruby_libvirt_connect_get(c), 1,
+                                      ruby_libvirt_connect_get(c));
 }
 
 /*
  * call-seq:
  *   conn.uri -> string
  *
- * Call +virConnectGetURI+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectGetURI]
+ * Call virConnectGetURI[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectGetURI]
  * to retrieve the canonical URI for this connection.
  */
-static VALUE libvirt_conn_uri(VALUE s) {
-    gen_call_string(virConnectGetURI, conn(s), 1, connect_get(s));
+static VALUE libvirt_connect_uri(VALUE c)
+{
+    ruby_libvirt_generate_call_string(virConnectGetURI,
+                                      ruby_libvirt_connect_get(c), 1,
+                                      ruby_libvirt_connect_get(c));
 }
 
 /*
  * call-seq:
  *   conn.max_vcpus(type=nil) -> fixnum
  *
- * Call +virConnectGetMaxVcpus+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectGetMaxVcpus]
+ * Call virConnectGetMaxVcpus[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectGetMaxVcpus]
  * to retrieve the maximum number of virtual cpus supported by the hypervisor
  * for this connection.
  */
-static VALUE libvirt_conn_max_vcpus(int argc, VALUE *argv, VALUE s) {
+static VALUE libvirt_connect_max_vcpus(int argc, VALUE *argv, VALUE c)
+{
     VALUE type;
 
     rb_scan_args(argc, argv, "01", &type);
 
-    gen_call_int(virConnectGetMaxVcpus, conn(s), connect_get(s),
-                 get_string_or_nil(type));
+    ruby_libvirt_generate_call_int(virConnectGetMaxVcpus,
+                                   ruby_libvirt_connect_get(c),
+                                   ruby_libvirt_connect_get(c),
+                                   ruby_libvirt_get_cstring_or_null(type));
 }
 
 /*
  * call-seq:
- *   conn.node_get_info -> Libvirt::Connect::Nodeinfo
+ *   conn.node_info -> Libvirt::Connect::Nodeinfo
  *
- * Call +virNodeGetInfo+[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeGetInfo]
+ * Call virNodeGetInfo[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeGetInfo]
  * to retrieve information about the node for this connection.
  */
-static VALUE libvirt_conn_node_get_info(VALUE s) {
+static VALUE libvirt_connect_node_info(VALUE c)
+{
     int r;
-    virConnectPtr conn = connect_get(s);
     virNodeInfo nodeinfo;
     VALUE result;
 
-    r = virNodeGetInfo(conn, &nodeinfo);
-    _E(r < 0, create_error(e_RetrieveError, "virNodeGetInfo", conn));
+    r = virNodeGetInfo(ruby_libvirt_connect_get(c), &nodeinfo);
+    ruby_libvirt_raise_error_if(r < 0, e_RetrieveError, "virNodeGetInfo",
+                                ruby_libvirt_connect_get(c));
 
     result = rb_class_new_instance(0, NULL, c_node_info);
     rb_iv_set(result, "@model", rb_str_new2(nodeinfo.model));
@@ -218,18 +278,19 @@ static VALUE libvirt_conn_node_get_info(VALUE s) {
  * call-seq:
  *   conn.node_free_memory -> fixnum
  *
- * Call +virNodeGetFreeMemory+[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeGetFreeMemory]
+ * Call virNodeGetFreeMemory[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeGetFreeMemory]
  * to retrieve the amount of free memory available on the host for this
  * connection.
  */
-static VALUE libvirt_conn_node_free_memory(VALUE s) {
-    virConnectPtr conn = connect_get(s);
+static VALUE libvirt_connect_node_free_memory(VALUE c)
+{
     unsigned long long freemem;
 
-    freemem = virNodeGetFreeMemory(conn);
+    freemem = virNodeGetFreeMemory(ruby_libvirt_connect_get(c));
 
-    _E(freemem == 0, create_error(e_RetrieveError, "virNodeGetFreeMemory",
-                                  conn));
+    ruby_libvirt_raise_error_if(freemem == 0, e_RetrieveError,
+                                "virNodeGetFreeMemory",
+                                ruby_libvirt_connect_get(c));
 
     return ULL2NUM(freemem);
 }
@@ -238,49 +299,50 @@ static VALUE libvirt_conn_node_free_memory(VALUE s) {
  * call-seq:
  *   conn.node_cells_free_memory(startCell=0, maxCells=#nodeCells) -> list
  *
- * Call +virNodeGetCellsFreeMemory+[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeGetCellsFreeMemory]
+ * Call virNodeGetCellsFreeMemory[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeGetCellsFreeMemory]
  * to retrieve the amount of free memory in each NUMA cell on the host for
  * this connection.
  */
-static VALUE libvirt_conn_node_cells_free_memory(int argc, VALUE *argv,
-                                                 VALUE s) {
-    int r;
-    virConnectPtr conn = connect_get(s);
-    VALUE cells;
-    VALUE start, max;
+static VALUE libvirt_connect_node_cells_free_memory(int argc, VALUE *argv,
+                                                    VALUE c)
+{
+    int i, r;
+    VALUE cells, start, max;
     unsigned long long *freeMems;
     virNodeInfo nodeinfo;
-    int i;
     unsigned int startCell, maxCells;
 
     rb_scan_args(argc, argv, "02", &start, &max);
 
-    if (NIL_P(start))
+    if (NIL_P(start)) {
         startCell = 0;
-    else
+    }
+    else {
         startCell = NUM2UINT(start);
+    }
 
     if (NIL_P(max)) {
-        r = virNodeGetInfo(conn, &nodeinfo);
-        _E(r < 0, create_error(e_RetrieveError, "virNodeGetInfo", conn));
+        r = virNodeGetInfo(ruby_libvirt_connect_get(c), &nodeinfo);
+        ruby_libvirt_raise_error_if(r < 0, e_RetrieveError, "virNodeGetInfo",
+                                    ruby_libvirt_connect_get(c));
         maxCells = nodeinfo.nodes;
     }
-    else
+    else {
         maxCells = NUM2UINT(max);
+    }
 
-    freeMems = ALLOC_N(unsigned long long, maxCells);
+    freeMems = alloca(sizeof(unsigned long long) * maxCells);
 
-    r = virNodeGetCellsFreeMemory(conn, freeMems, startCell, maxCells);
-    if (r < 0) {
-        xfree(freeMems);
-        rb_exc_raise(create_error(e_RetrieveError, "virNodeGetCellsFreeMemory",
-                                  conn));
-    }
+    r = virNodeGetCellsFreeMemory(ruby_libvirt_connect_get(c), freeMems,
+                                  startCell, maxCells);
+    ruby_libvirt_raise_error_if(r < 0, e_RetrieveError,
+                                "virNodeGetCellsFreeMemory",
+                                ruby_libvirt_connect_get(c));
 
     cells = rb_ary_new2(r);
-    for (i = 0; i < r; i++)
-        rb_ary_push(cells, ULL2NUM(freeMems[i]));
-    xfree(freeMems);
+    for (i = 0; i < r; i++) {
+        rb_ary_store(cells, i, ULL2NUM(freeMems[i]));
+    }
 
     return cells;
 }
@@ -288,19 +350,21 @@ static VALUE libvirt_conn_node_cells_free_memory(int argc, VALUE *argv,
 #if HAVE_VIRNODEGETSECURITYMODEL
 /*
  * call-seq:
- *   conn.node_get_security_model -> Libvirt::Connect::NodeSecurityModel
+ *   conn.node_security_model -> Libvirt::Connect::NodeSecurityModel
  *
- * Call +virNodeGetSecurityModel+[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeGetSecurityModel]
+ * Call virNodeGetSecurityModel[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeGetSecurityModel]
  * to retrieve the security model in use on the host for this connection.
  */
-static VALUE libvirt_conn_node_get_security_model(VALUE s) {
+static VALUE libvirt_connect_node_security_model(VALUE c)
+{
     virSecurityModel secmodel;
-    virConnectPtr conn = connect_get(s);
     int r;
     VALUE result;
 
-    r = virNodeGetSecurityModel(conn, &secmodel);
-    _E(r < 0, create_error(e_RetrieveError, "virNodeGetSecurityModel", conn));
+    r = virNodeGetSecurityModel(ruby_libvirt_connect_get(c), &secmodel);
+    ruby_libvirt_raise_error_if(r < 0, e_RetrieveError,
+                                "virNodeGetSecurityModel",
+                                ruby_libvirt_connect_get(c));
 
     result = rb_class_new_instance(0, NULL, c_node_security_model);
     rb_iv_set(result, "@model", rb_str_new2(secmodel.model));
@@ -315,11 +379,14 @@ static VALUE libvirt_conn_node_get_security_model(VALUE s) {
  * call-seq:
  *   conn.encrypted? -> [True|False]
  *
- * Call +virConnectIsEncrypted+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectIsEncrypted]
+ * Call virConnectIsEncrypted[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectIsEncrypted]
  * to determine if the connection is encrypted.
  */
-static VALUE libvirt_conn_encrypted_p(VALUE s) {
-    gen_call_truefalse(virConnectIsEncrypted, conn(s), connect_get(s));
+static VALUE libvirt_connect_encrypted_p(VALUE c)
+{
+    ruby_libvirt_generate_call_truefalse(virConnectIsEncrypted,
+                                         ruby_libvirt_connect_get(c),
+                                         ruby_libvirt_connect_get(c));
 }
 #endif
 
@@ -328,11 +395,14 @@ static VALUE libvirt_conn_encrypted_p(VALUE s) {
  * call-seq:
  *   conn.secure? -> [True|False]
  *
- * Call +virConnectIsSecure+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectIsSecure]
+ * Call virConnectIsSecure[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectIsSecure]
  * to determine if the connection is secure.
  */
-static VALUE libvirt_conn_secure_p(VALUE s) {
-    gen_call_truefalse(virConnectIsSecure, conn(s), connect_get(s));
+static VALUE libvirt_connect_secure_p(VALUE c)
+{
+    ruby_libvirt_generate_call_truefalse(virConnectIsSecure,
+                                         ruby_libvirt_connect_get(c),
+                                         ruby_libvirt_connect_get(c));
 }
 #endif
 
@@ -340,11 +410,14 @@ static VALUE libvirt_conn_secure_p(VALUE s) {
  * call-seq:
  *   conn.capabilities -> string
  *
- * Call +virConnectGetCapabilities+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectGetCapabilities]
+ * Call virConnectGetCapabilities[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectGetCapabilities]
  * to retrieve the capabilities XML for this connection.
  */
-static VALUE libvirt_conn_capabilities(VALUE s) {
-    gen_call_string(virConnectGetCapabilities, conn(s), 1, connect_get(s));
+static VALUE libvirt_connect_capabilities(VALUE c)
+{
+    ruby_libvirt_generate_call_string(virConnectGetCapabilities,
+                                      ruby_libvirt_connect_get(c), 1,
+                                      ruby_libvirt_connect_get(c));
 }
 
 #if HAVE_VIRCONNECTCOMPARECPU
@@ -352,20 +425,22 @@ static VALUE libvirt_conn_capabilities(VALUE s) {
  * call-seq:
  *   conn.compare_cpu(xml, flags=0) -> compareflag
  *
- * Call +virConnectCompareCPU+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectCompareCPU]
+ * Call virConnectCompareCPU[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectCompareCPU]
  * to compare the host CPU with the XML contained in xml.  Returns one of
  * Libvirt::CPU_COMPARE_ERROR, Libvirt::CPU_COMPARE_INCOMPATIBLE,
  * Libvirt::CPU_COMPARE_IDENTICAL, or Libvirt::CPU_COMPARE_SUPERSET.
  */
-static VALUE libvirt_conn_compare_cpu(int argc, VALUE *argv, VALUE s) {
+static VALUE libvirt_connect_compare_cpu(int argc, VALUE *argv, VALUE c)
+{
     VALUE xml, flags;
 
     rb_scan_args(argc, argv, "11", &xml, &flags);
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
 
-    gen_call_int(virConnectCompareCPU, conn(s), connect_get(s),
-                 StringValueCStr(xml), NUM2UINT(flags));
+    ruby_libvirt_generate_call_int(virConnectCompareCPU,
+                                   ruby_libvirt_connect_get(c),
+                                   ruby_libvirt_connect_get(c),
+                                   StringValueCStr(xml),
+                                   ruby_libvirt_value_to_uint(flags));
 }
 #endif
 
@@ -375,70 +450,48 @@ static VALUE libvirt_conn_compare_cpu(int argc, VALUE *argv, VALUE s) {
  * call-seq:
  *   conn.baseline_cpu([xml, xml2, ...], flags=0) -> XML
  *
- * Call +virConnectBaselineCPU+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectBaselineCPU]
+ * Call virConnectBaselineCPU[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectBaselineCPU]
  * to compare the most feature-rich CPU which is compatible with all
  * given host CPUs.
  */
-static VALUE libvirt_conn_baseline_cpu(int argc, VALUE *argv, VALUE s) {
-    VALUE xmlcpus, flags_val;
-    virConnectPtr conn = connect_get(s);
+static VALUE libvirt_connect_baseline_cpu(int argc, VALUE *argv, VALUE c)
+{
+    VALUE xmlcpus, flags, retval, entry;
     char *r;
-    VALUE retval;
-    unsigned int ncpus, flags;
-    VALUE entry;
+    unsigned int ncpus;
     const char **xmllist;
-    int i;
-    int exception = 0;
-    struct rb_ary_entry_arg arg;
+    int i, exception = 0;
 
-    rb_scan_args(argc, argv, "11", &xmlcpus, &flags_val);
-    /*
-     * We check flags up-front here so that we get a TypeError early on if
-     * flags is bogus.
-     */
-    if (NIL_P(flags_val))
-        flags = 0;
-    else
-        flags = NUM2UINT(flags_val);
+    rb_scan_args(argc, argv, "11", &xmlcpus, &flags);
 
     Check_Type(xmlcpus, T_ARRAY);
 
-    if (RARRAY_LEN(xmlcpus) < 1)
-        rb_raise(rb_eArgError, "wrong number of cpu arguments (%d for 1 or more)",
+    if (RARRAY_LEN(xmlcpus) < 1) {
+        rb_raise(rb_eArgError,
+                 "wrong number of cpu arguments (%ld for 1 or more)",
                  RARRAY_LEN(xmlcpus));
+    }
 
     ncpus = RARRAY_LEN(xmlcpus);
-    xmllist = ALLOC_N(const char *, ncpus);
+    xmllist = alloca(sizeof(const char *) * ncpus);
 
     for (i = 0; i < ncpus; i++) {
-        arg.arr = xmlcpus;
-        arg.elem = i;
-        entry = rb_protect(rb_ary_entry_wrap, (VALUE)&arg, &exception);
-        if (exception) {
-            xfree(xmllist);
-            rb_jump_tag(exception);
-        }
-
-        xmllist[i] = (char *)rb_protect(rb_string_value_cstr_wrap,
-                                        (VALUE)&entry, &exception);
-        if (exception) {
-            xfree(xmllist);
-            rb_jump_tag(exception);
-        }
+        entry = rb_ary_entry(xmlcpus, i);
+        xmllist[i] = StringValueCStr(entry);
     }
 
-    r = virConnectBaselineCPU(conn, xmllist, ncpus, flags);
-    xfree(xmllist);
-    _E(r == NULL, create_error(e_RetrieveError, "virConnectBaselineCPU", conn));
+    r = virConnectBaselineCPU(ruby_libvirt_connect_get(c), xmllist, ncpus,
+                              ruby_libvirt_value_to_uint(flags));
+    ruby_libvirt_raise_error_if(r == NULL, e_RetrieveError,
+                                "virConnectBaselineCPU",
+                                ruby_libvirt_connect_get(c));
 
-    retval = rb_protect(rb_str_new2_wrap, (VALUE)&r, &exception);
+    retval = rb_protect(ruby_libvirt_str_new2_wrap, (VALUE)&r, &exception);
+    free(r);
     if (exception) {
-        free(r);
         rb_jump_tag(exception);
     }
 
-    free(r);
-
     return retval;
 }
 #endif
@@ -446,34 +499,36 @@ static VALUE libvirt_conn_baseline_cpu(int argc, VALUE *argv, VALUE s) {
 #if HAVE_VIRCONNECTDOMAINEVENTREGISTERANY || HAVE_VIRCONNECTDOMAINEVENTREGISTER
 static int domain_event_lifecycle_callback(virConnectPtr conn,
                                            virDomainPtr dom, int event,
-                                           int detail, void *opaque) {
+                                           int detail, void *opaque)
+{
     VALUE passthrough = (VALUE)opaque;
-    VALUE cb;
-    VALUE cb_opaque;
-    VALUE newc;
+    VALUE cb, cb_opaque, newc;
 
-    if (TYPE(passthrough) != T_ARRAY)
-        rb_raise(rb_eTypeError,
-                 "wrong domain event lifecycle callback argument type (expected Array)");
+    Check_Type(passthrough, T_ARRAY);
 
-    if (RARRAY_LEN(passthrough) != 2)
-        rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)",
+    if (RARRAY_LEN(passthrough) != 2) {
+        rb_raise(rb_eArgError, "wrong number of arguments (%ld for 2)",
                  RARRAY_LEN(passthrough));
+    }
 
     cb = rb_ary_entry(passthrough, 0);
     cb_opaque = rb_ary_entry(passthrough, 1);
 
-    newc = connect_new(conn);
-    if (strcmp(rb_obj_classname(cb), "Symbol") == 0)
+    newc = ruby_libvirt_connect_new(conn);
+    if (strcmp(rb_obj_classname(cb), "Symbol") == 0) {
         rb_funcall(rb_class_of(cb), rb_to_id(cb), 5, newc,
-                   domain_new(dom, newc), INT2NUM(event), INT2NUM(detail),
-                   cb_opaque);
-    else if (strcmp(rb_obj_classname(cb), "Proc") == 0)
-        rb_funcall(cb, rb_intern("call"), 5, newc, domain_new(dom, newc),
-                   INT2NUM(event), INT2NUM(detail), cb_opaque);
-    else
+                   ruby_libvirt_domain_new(dom, newc), INT2NUM(event),
+                   INT2NUM(detail), cb_opaque);
+    }
+    else if (strcmp(rb_obj_classname(cb), "Proc") == 0) {
+        rb_funcall(cb, rb_intern("call"), 5, newc,
+                   ruby_libvirt_domain_new(dom, newc), INT2NUM(event),
+                   INT2NUM(detail), cb_opaque);
+    }
+    else {
         rb_raise(rb_eTypeError,
                  "wrong domain event lifecycle callback (expected Symbol or Proc)");
+    }
 
     return 0;
 }
@@ -481,97 +536,104 @@ static int domain_event_lifecycle_callback(virConnectPtr conn,
 
 #if HAVE_VIRCONNECTDOMAINEVENTREGISTERANY
 static int domain_event_reboot_callback(virConnectPtr conn, virDomainPtr dom,
-                                        void *opaque) {
+                                        void *opaque)
+{
     VALUE passthrough = (VALUE)opaque;
-    VALUE cb;
-    VALUE cb_opaque;
-    VALUE newc;
+    VALUE cb, cb_opaque, newc;
 
-    if (TYPE(passthrough) != T_ARRAY)
-        rb_raise(rb_eTypeError,
-                 "wrong domain event reboot callback argument type (expected Array)");
+    Check_Type(passthrough, T_ARRAY);
 
-    if (RARRAY_LEN(passthrough) != 2)
-        rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)",
+    if (RARRAY_LEN(passthrough) != 2) {
+        rb_raise(rb_eArgError, "wrong number of arguments (%ld for 2)",
                  RARRAY_LEN(passthrough));
+    }
 
     cb = rb_ary_entry(passthrough, 0);
     cb_opaque = rb_ary_entry(passthrough, 1);
 
-    newc = connect_new(conn);
-    if (strcmp(rb_obj_classname(cb), "Symbol") == 0)
+    newc = ruby_libvirt_connect_new(conn);
+    if (strcmp(rb_obj_classname(cb), "Symbol") == 0) {
         rb_funcall(rb_class_of(cb), rb_to_id(cb), 3, newc,
-                   domain_new(dom, newc), cb_opaque);
-    else if (strcmp(rb_obj_classname(cb), "Proc") == 0)
-        rb_funcall(cb, rb_intern("call"), 3, newc, domain_new(dom, newc),
-                   cb_opaque);
-    else
+                   ruby_libvirt_domain_new(dom, newc), cb_opaque);
+    }
+    else if (strcmp(rb_obj_classname(cb), "Proc") == 0) {
+        rb_funcall(cb, rb_intern("call"), 3, newc,
+                   ruby_libvirt_domain_new(dom, newc), cb_opaque);
+    }
+    else {
         rb_raise(rb_eTypeError,
                  "wrong domain event reboot callback (expected Symbol or Proc)");
+    }
 
     return 0;
 }
 
 static int domain_event_rtc_callback(virConnectPtr conn, virDomainPtr dom,
-                                     long long utc_offset, void *opaque) {
+                                     long long utc_offset, void *opaque)
+{
     VALUE passthrough = (VALUE)opaque;
-    VALUE cb;
-    VALUE cb_opaque;
-    VALUE newc;
+    VALUE cb, cb_opaque, newc;
 
-    if (TYPE(passthrough) != T_ARRAY)
-        rb_raise(rb_eTypeError,
-                 "wrong domain event rtc callback argument type (expected Array)");
+    Check_Type(passthrough, T_ARRAY);
 
-    if (RARRAY_LEN(passthrough) != 2)
-        rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)",
+    if (RARRAY_LEN(passthrough) != 2) {
+        rb_raise(rb_eArgError, "wrong number of arguments (%ld for 2)",
                  RARRAY_LEN(passthrough));
+    }
 
     cb = rb_ary_entry(passthrough, 0);
     cb_opaque = rb_ary_entry(passthrough, 1);
 
-    newc = connect_new(conn);
-    if (strcmp(rb_obj_classname(cb), "Symbol") == 0)
+    newc = ruby_libvirt_connect_new(conn);
+    if (strcmp(rb_obj_classname(cb), "Symbol") == 0) {
         rb_funcall(rb_class_of(cb), rb_to_id(cb), 4, newc,
-                   domain_new(dom, newc), LL2NUM(utc_offset), cb_opaque);
-    else if (strcmp(rb_obj_classname(cb), "Proc") == 0)
-        rb_funcall(cb, rb_intern("call"), 4, newc, domain_new(dom, newc),
-                   LL2NUM(utc_offset), cb_opaque);
-    else
+                   ruby_libvirt_domain_new(dom, newc), LL2NUM(utc_offset),
+                   cb_opaque);
+    }
+    else if (strcmp(rb_obj_classname(cb), "Proc") == 0) {
+        rb_funcall(cb, rb_intern("call"), 4, newc,
+                   ruby_libvirt_domain_new(dom, newc), LL2NUM(utc_offset),
+                   cb_opaque);
+    }
+    else {
         rb_raise(rb_eTypeError,
                  "wrong domain event rtc callback (expected Symbol or Proc)");
+    }
 
     return 0;
 }
 
 static int domain_event_watchdog_callback(virConnectPtr conn, virDomainPtr dom,
-                                          int action, void *opaque) {
+                                          int action, void *opaque)
+{
     VALUE passthrough = (VALUE)opaque;
-    VALUE cb;
-    VALUE cb_opaque;
-    VALUE newc;
+    VALUE cb, cb_opaque, newc;
 
-    if (TYPE(passthrough) != T_ARRAY)
-        rb_raise(rb_eTypeError,
-                 "wrong domain event watchdog callback argument type (expected Array)");
+    Check_Type(passthrough, T_ARRAY);
 
-    if (RARRAY_LEN(passthrough) != 2)
-        rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)",
+    if (RARRAY_LEN(passthrough) != 2) {
+        rb_raise(rb_eArgError, "wrong number of arguments (%ld for 2)",
                  RARRAY_LEN(passthrough));
+    }
 
     cb = rb_ary_entry(passthrough, 0);
     cb_opaque = rb_ary_entry(passthrough, 1);
 
-    newc = connect_new(conn);
-    if (strcmp(rb_obj_classname(cb), "Symbol") == 0)
+    newc = ruby_libvirt_connect_new(conn);
+    if (strcmp(rb_obj_classname(cb), "Symbol") == 0) {
         rb_funcall(rb_class_of(cb), rb_to_id(cb), 4, newc,
-                   domain_new(dom, newc), INT2NUM(action), cb_opaque);
-    else if (strcmp(rb_obj_classname(cb), "Proc") == 0)
-        rb_funcall(cb, rb_intern("call"), 4, newc, domain_new(dom, newc),
-                   INT2NUM(action), cb_opaque);
-    else
+                   ruby_libvirt_domain_new(dom, newc), INT2NUM(action),
+                   cb_opaque);
+    }
+    else if (strcmp(rb_obj_classname(cb), "Proc") == 0) {
+        rb_funcall(cb, rb_intern("call"), 4, newc,
+                   ruby_libvirt_domain_new(dom, newc), INT2NUM(action),
+                   cb_opaque);
+    }
+    else {
         rb_raise(rb_eTypeError,
                  "wrong domain event watchdog callback (expected Symbol or Proc)");
+    }
 
     return 0;
 }
@@ -580,35 +642,37 @@ static int domain_event_io_error_callback(virConnectPtr conn, virDomainPtr dom,
                                           const char *src_path,
                                           const char *dev_alias,
                                           int action,
-                                          void *opaque) {
+                                          void *opaque)
+{
     VALUE passthrough = (VALUE)opaque;
-    VALUE cb;
-    VALUE cb_opaque;
-    VALUE newc;
+    VALUE cb, cb_opaque, newc;
 
-    if (TYPE(passthrough) != T_ARRAY)
-        rb_raise(rb_eTypeError,
-                 "wrong domain event IO error callback argument type (expected Array)");
+    Check_Type(passthrough, T_ARRAY);
 
-    if (RARRAY_LEN(passthrough) != 2)
-        rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)",
+    if (RARRAY_LEN(passthrough) != 2) {
+        rb_raise(rb_eArgError, "wrong number of arguments (%ld for 2)",
                  RARRAY_LEN(passthrough));
+    }
 
     cb = rb_ary_entry(passthrough, 0);
     cb_opaque = rb_ary_entry(passthrough, 1);
 
-    newc = connect_new(conn);
-    if (strcmp(rb_obj_classname(cb), "Symbol") == 0)
+    newc = ruby_libvirt_connect_new(conn);
+    if (strcmp(rb_obj_classname(cb), "Symbol") == 0) {
         rb_funcall(rb_class_of(cb), rb_to_id(cb), 6, newc,
-                   domain_new(dom, newc), rb_str_new2(src_path),
+                   ruby_libvirt_domain_new(dom, newc), rb_str_new2(src_path),
                    rb_str_new2(dev_alias), INT2NUM(action), cb_opaque);
-    else if (strcmp(rb_obj_classname(cb), "Proc") == 0)
-        rb_funcall(cb, rb_intern("call"), 6, newc, domain_new(dom, newc),
+    }
+    else if (strcmp(rb_obj_classname(cb), "Proc") == 0) {
+        rb_funcall(cb, rb_intern("call"), 6, newc,
+                   ruby_libvirt_domain_new(dom, newc),
                    rb_str_new2(src_path), rb_str_new2(dev_alias),
                    INT2NUM(action), cb_opaque);
-    else
+    }
+    else {
         rb_raise(rb_eTypeError,
                  "wrong domain event IO error callback (expected Symbol or Proc)");
+    }
 
     return 0;
 }
@@ -619,36 +683,38 @@ static int domain_event_io_error_reason_callback(virConnectPtr conn,
                                                  const char *dev_alias,
                                                  int action,
                                                  const char *reason,
-                                                 void *opaque) {
+                                                 void *opaque)
+{
     VALUE passthrough = (VALUE)opaque;
-    VALUE cb;
-    VALUE cb_opaque;
-    VALUE newc;
+    VALUE cb, cb_opaque, newc;
 
-    if (TYPE(passthrough) != T_ARRAY)
-        rb_raise(rb_eTypeError,
-                 "wrong domain event IO error reason callback argument type (expected Array)");
+    Check_Type(passthrough, T_ARRAY);
 
-    if (RARRAY_LEN(passthrough) != 2)
-        rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)",
+    if (RARRAY_LEN(passthrough) != 2) {
+        rb_raise(rb_eArgError, "wrong number of arguments (%ld for 2)",
                  RARRAY_LEN(passthrough));
+    }
 
     cb = rb_ary_entry(passthrough, 0);
     cb_opaque = rb_ary_entry(passthrough, 1);
 
-    newc = connect_new(conn);
-    if (strcmp(rb_obj_classname(cb), "Symbol") == 0)
+    newc = ruby_libvirt_connect_new(conn);
+    if (strcmp(rb_obj_classname(cb), "Symbol") == 0) {
         rb_funcall(rb_class_of(cb), rb_to_id(cb), 7, newc,
-                   domain_new(dom, newc), rb_str_new2(src_path),
+                   ruby_libvirt_domain_new(dom, newc), rb_str_new2(src_path),
                    rb_str_new2(dev_alias), INT2NUM(action),
                    rb_str_new2(reason), cb_opaque);
-    else if (strcmp(rb_obj_classname(cb), "Proc") == 0)
-        rb_funcall(cb, rb_intern("call"), 7, newc, domain_new(dom, newc),
+    }
+    else if (strcmp(rb_obj_classname(cb), "Proc") == 0) {
+        rb_funcall(cb, rb_intern("call"), 7, newc,
+                   ruby_libvirt_domain_new(dom, newc),
                    rb_str_new2(src_path), rb_str_new2(dev_alias),
                    INT2NUM(action), rb_str_new2(reason), cb_opaque);
-    else
+    }
+    else {
         rb_raise(rb_eTypeError,
                  "wrong domain event IO error reason callback (expected Symbol or Proc)");
+    }
 
     return 0;
 }
@@ -659,24 +725,18 @@ static int domain_event_graphics_callback(virConnectPtr conn, virDomainPtr dom,
                                           virDomainEventGraphicsAddressPtr remote,
                                           const char *authScheme,
                                           virDomainEventGraphicsSubjectPtr subject,
-                                          void *opaque) {
+                                          void *opaque)
+{
     VALUE passthrough = (VALUE)opaque;
-    VALUE cb;
-    VALUE cb_opaque;
-    VALUE newc;
-    VALUE local_hash;
-    VALUE remote_hash;
-    VALUE subject_array;
-    VALUE pair;
+    VALUE cb, cb_opaque, newc, local_hash, remote_hash, subject_array, pair;
     int i;
 
-    if (TYPE(passthrough) != T_ARRAY)
-        rb_raise(rb_eTypeError,
-                 "wrong domain event graphics callback argument type (expected Array)");
+    Check_Type(passthrough, T_ARRAY);
 
-    if (RARRAY_LEN(passthrough) != 2)
-        rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)",
+    if (RARRAY_LEN(passthrough) != 2) {
+        rb_raise(rb_eArgError, "wrong number of arguments (%ld for 2)",
                  RARRAY_LEN(passthrough));
+    }
 
     cb = rb_ary_entry(passthrough, 0);
     cb_opaque = rb_ary_entry(passthrough, 1);
@@ -702,19 +762,23 @@ static int domain_event_graphics_callback(virConnectPtr conn, virDomainPtr dom,
         rb_ary_store(subject_array, i, pair);
     }
 
-    newc = connect_new(conn);
-    if (strcmp(rb_obj_classname(cb), "Symbol") == 0)
+    newc = ruby_libvirt_connect_new(conn);
+    if (strcmp(rb_obj_classname(cb), "Symbol") == 0) {
         rb_funcall(rb_class_of(cb), rb_to_id(cb), 8, newc,
-                   domain_new(dom, newc), INT2NUM(phase), local_hash,
-                   remote_hash, rb_str_new2(authScheme), subject_array,
-                   cb_opaque);
-    else if (strcmp(rb_obj_classname(cb), "Proc") == 0)
-        rb_funcall(cb, rb_intern("call"), 8, newc, domain_new(dom, newc),
-                   INT2NUM(phase), local_hash, remote_hash,
-                   rb_str_new2(authScheme), subject_array, cb_opaque);
-    else
+                   ruby_libvirt_domain_new(dom, newc), INT2NUM(phase),
+                   local_hash, remote_hash, rb_str_new2(authScheme),
+                   subject_array, cb_opaque);
+    }
+    else if (strcmp(rb_obj_classname(cb), "Proc") == 0) {
+        rb_funcall(cb, rb_intern("call"), 8, newc,
+                   ruby_libvirt_domain_new(dom, newc), INT2NUM(phase),
+                   local_hash, remote_hash, rb_str_new2(authScheme),
+                   subject_array, cb_opaque);
+    }
+    else {
         rb_raise(rb_eTypeError,
                  "wrong domain event graphics callback (expected Symbol or Proc)");
+    }
 
     return 0;
 }
@@ -723,7 +787,7 @@ static int domain_event_graphics_callback(virConnectPtr conn, virDomainPtr dom,
  * call-seq:
  *   conn.domain_event_register_any(eventID, callback, dom=nil, opaque=nil) -> fixnum
  *
- * Call +virConnectDomainEventRegisterAny+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectDomainEventRegisterAny]
+ * Call virConnectDomainEventRegisterAny[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectDomainEventRegisterAny]
  * to register callback for eventID with libvirt.  The eventID must be one of
  * the Libvirt::Connect::DOMAIN_EVENT_ID_* constants.  The callback can either
  * be a Symbol (that is the name of a method to callback) or a Proc.  Note that
@@ -744,22 +808,26 @@ static int domain_event_graphics_callback(virConnectPtr conn, virDomainPtr dom,
  * libvirt-specific handle, which must be used by the application to
  * deregister the callback later (see domain_event_deregister_any).
  */
-static VALUE libvirt_conn_domain_event_register_any(int argc, VALUE *argv,
-                                                    VALUE c) {
-    VALUE eventID, cb, dom, opaque;
+static VALUE libvirt_connect_domain_event_register_any(int argc, VALUE *argv,
+                                                       VALUE c)
+{
+    VALUE eventID, cb, dom, opaque, passthrough;
     virDomainPtr domain;
     virConnectDomainEventGenericCallback internalcb = NULL;
-    VALUE passthrough;
 
     rb_scan_args(argc, argv, "22", &eventID, &cb, &dom, &opaque);
 
-    if (!is_symbol_or_proc(cb))
-        rb_raise(rb_eTypeError, "wrong argument type (expected Symbol or Proc)");
+    if (!ruby_libvirt_is_symbol_or_proc(cb)) {
+        rb_raise(rb_eTypeError,
+                 "wrong argument type (expected Symbol or Proc)");
+    }
 
-    if (NIL_P(dom))
+    if (NIL_P(dom)) {
         domain = NULL;
-    else
-        domain = domain_get(dom);
+    }
+    else {
+        domain = ruby_libvirt_domain_get(dom);
+    }
 
     switch(NUM2INT(eventID)) {
     case VIR_DOMAIN_EVENT_ID_LIFECYCLE:
@@ -793,23 +861,28 @@ static VALUE libvirt_conn_domain_event_register_any(int argc, VALUE *argv,
     rb_ary_store(passthrough, 0, cb);
     rb_ary_store(passthrough, 1, opaque);
 
-    gen_call_int(virConnectDomainEventRegisterAny, conn(c), connect_get(c),
-                 domain, NUM2INT(eventID), internalcb, (void *)passthrough,
-                 NULL);
+    ruby_libvirt_generate_call_int(virConnectDomainEventRegisterAny,
+                                   ruby_libvirt_connect_get(c),
+                                   ruby_libvirt_connect_get(c), domain,
+                                   NUM2INT(eventID), internalcb,
+                                   (void *)passthrough, NULL);
 }
 
 /*
  * call-seq:
  *   conn.domain_event_deregister_any(callbackID) -> nil
  *
- * Call +virConnectDomainEventDeregisterAny+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectDomainEventDeregisterAny]
+ * Call virConnectDomainEventDeregisterAny[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectDomainEventDeregisterAny]
  * to deregister a callback from libvirt.  The callbackID must be a
  * libvirt-specific handle returned by domain_event_register_any.
  */
-static VALUE libvirt_conn_domain_event_deregister_any(VALUE c,
-                                                      VALUE callbackID) {
-    gen_call_void(virConnectDomainEventDeregisterAny, conn(c), connect_get(c),
-                  NUM2INT(callbackID));
+static VALUE libvirt_connect_domain_event_deregister_any(VALUE c,
+                                                         VALUE callbackID)
+{
+    ruby_libvirt_generate_call_nil(virConnectDomainEventDeregisterAny,
+                                   ruby_libvirt_connect_get(c),
+                                   ruby_libvirt_connect_get(c),
+                                   NUM2INT(callbackID));
 }
 #endif
 
@@ -823,14 +896,15 @@ static VALUE libvirt_conn_domain_event_deregister_any(VALUE c,
  */
 static int domain_event_callback(virConnectPtr conn,
                                  virDomainPtr dom, int event,
-                                 int detail, void *opaque) {
+                                 int detail, void *opaque)
+{
     return domain_event_lifecycle_callback(conn, dom, event, detail, opaque);
 }
 /*
  * call-seq:
  *   conn.domain_event_register(callback, opaque=nil) -> nil
  *
- * Call +virConnectDomainEventRegister+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectDomainEventRegister]
+ * Call virConnectDomainEventRegister[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectDomainEventRegister]
  * to register callback for domain lifecycle events with libvirt.  The
  * callback can either be a Symbol (that is the name of a method to callback)
  * or a Proc.  The callback must accept 5 parameters: Libvirt::Connect,
@@ -839,37 +913,45 @@ static int domain_event_callback(virConnectPtr conn,
  * callback as "opaque".  This method is deprecated in favor of
  * domain_event_register_any.
  */
-static VALUE libvirt_conn_domain_event_register(int argc, VALUE *argv,
-                                                VALUE c) {
-    VALUE cb, opaque;
-    VALUE passthrough;
+static VALUE libvirt_connect_domain_event_register(int argc, VALUE *argv,
+                                                   VALUE c)
+{
+    VALUE cb, opaque, passthrough;
 
     rb_scan_args(argc, argv, "11", &cb, &opaque);
 
-    if (!is_symbol_or_proc(cb))
-        rb_raise(rb_eTypeError, "wrong argument type (expected Symbol or Proc)");
+    if (!ruby_libvirt_is_symbol_or_proc(cb)) {
+        rb_raise(rb_eTypeError,
+                 "wrong argument type (expected Symbol or Proc)");
+    }
 
     passthrough = rb_ary_new();
     rb_ary_store(passthrough, 0, cb);
     rb_ary_store(passthrough, 1, opaque);
 
-    gen_call_void(virConnectDomainEventRegister, conn(c), connect_get(c),
-                  domain_event_callback, (void *)passthrough, NULL);
+    ruby_libvirt_generate_call_nil(virConnectDomainEventRegister,
+                                   ruby_libvirt_connect_get(c),
+                                   ruby_libvirt_connect_get(c),
+                                   domain_event_callback, (void *)passthrough,
+                                   NULL);
 }
 
 /*
  * call-seq:
  *   conn.domain_event_deregister(callback) -> nil
  *
- * Call +virConnectDomainEventDeregister+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectDomainEventDeregister]
+ * Call virConnectDomainEventDeregister[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectDomainEventDeregister]
  * to deregister the event callback from libvirt.  This method is deprecated
  * in favor of domain_event_deregister_any (though they cannot be mixed; if
  * the callback was registered with domain_event_register, it must be
  * deregistered with domain_event_deregister).
  */
-static VALUE libvirt_conn_domain_event_deregister(VALUE c) {
-    gen_call_void(virConnectDomainEventDeregister, conn(c), connect_get(c),
-                  domain_event_callback);
+static VALUE libvirt_connect_domain_event_deregister(VALUE c)
+{
+    ruby_libvirt_generate_call_nil(virConnectDomainEventDeregister,
+                                   ruby_libvirt_connect_get(c),
+                                   ruby_libvirt_connect_get(c),
+                                   domain_event_callback);
 }
 #endif
 
@@ -877,58 +959,47 @@ static VALUE libvirt_conn_domain_event_deregister(VALUE c) {
  * call-seq:
  *   conn.num_of_domains -> fixnum
  *
- * Call +virConnectNumOfDomains+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfDomains]
+ * Call virConnectNumOfDomains[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfDomains]
  * to retrieve the number of active domains on this connection.
  */
-static VALUE libvirt_conn_num_of_domains(VALUE s) {
-    gen_conn_num_of(s, Domains);
+static VALUE libvirt_connect_num_of_domains(VALUE c)
+{
+    gen_conn_num_of(c, Domains);
 }
 
 /*
  * call-seq:
  *   conn.list_domains -> list
  *
- * Call +virConnectListDomains+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListDomains]
+ * Call virConnectListDomains[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListDomains]
  * to retrieve a list of active domain IDs on this connection.
  */
-static VALUE libvirt_conn_list_domains(VALUE s) {
+static VALUE libvirt_connect_list_domains(VALUE c)
+{
     int i, r, num, *ids;
-    virConnectPtr conn = connect_get(s);
     VALUE result;
-    int exception = 0;
-    struct rb_ary_push_arg args;
 
-    num = virConnectNumOfDomains(conn);
-    _E(num < 0, create_error(e_RetrieveError, "virConnectNumOfDomains", conn));
+    num = virConnectNumOfDomains(ruby_libvirt_connect_get(c));
+    ruby_libvirt_raise_error_if(num < 0, e_RetrieveError,
+                                "virConnectNumOfDomains",
+                                ruby_libvirt_connect_get(c));
+
+    result = rb_ary_new2(num);
+
     if (num == 0) {
-        result = rb_ary_new2(num);
         return result;
     }
 
-    ids = ALLOC_N(int, num);
-    r = virConnectListDomains(conn, ids, num);
-    if (r < 0) {
-        xfree(ids);
-        rb_exc_raise(create_error(e_RetrieveError, "virConnectListDomains",
-                                  conn));
-    }
-
-    result = rb_protect(rb_ary_new2_wrap, (VALUE)&num, &exception);
-    if (exception) {
-        xfree(ids);
-        rb_jump_tag(exception);
-    }
+    ids = alloca(sizeof(int) * num);
+    r = virConnectListDomains(ruby_libvirt_connect_get(c), ids, num);
+    ruby_libvirt_raise_error_if(r < 0, e_RetrieveError,
+                                "virConnectListDomains",
+                                ruby_libvirt_connect_get(c));
 
     for (i = 0; i < num; i++) {
-        args.arr = result;
-        args. value = INT2NUM(ids[i]);
-        rb_protect(rb_ary_push_wrap, (VALUE)&args, &exception);
-        if (exception) {
-            xfree(ids);
-            rb_jump_tag(exception);
-        }
+        rb_ary_store(result, i, INT2NUM(ids[i]));
     }
-    xfree(ids);
+
     return result;
 }
 
@@ -936,46 +1007,48 @@ static VALUE libvirt_conn_list_domains(VALUE s) {
  * call-seq:
  *   conn.num_of_defined_domains -> fixnum
  *
- * Call +virConnectNumOfDefinedDomains+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfDefinedDomains]
+ * Call virConnectNumOfDefinedDomains[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfDefinedDomains]
  * to retrieve the number of inactive domains on this connection.
  */
-static VALUE libvirt_conn_num_of_defined_domains(VALUE s) {
-    gen_conn_num_of(s, DefinedDomains);
+static VALUE libvirt_connect_num_of_defined_domains(VALUE c)
+{
+    gen_conn_num_of(c, DefinedDomains);
 }
 
 /*
  * call-seq:
  *   conn.list_defined_domains -> list
  *
- * Call +virConnectListDefinedDomains+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListDefinedDomains]
+ * Call virConnectListDefinedDomains[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListDefinedDomains]
  * to retrieve a list of inactive domain names on this connection.
  */
-static VALUE libvirt_conn_list_defined_domains(VALUE s) {
-    gen_conn_list_names(s, DefinedDomains);
+static VALUE libvirt_connect_list_defined_domains(VALUE c)
+{
+    gen_conn_list_names(c, DefinedDomains);
 }
 
 /*
  * call-seq:
  *   conn.create_domain_linux(xml, flags=0) -> Libvirt::Domain
  *
- * Call +virDomainCreateLinux+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainCreateLinux]
+ * Call virDomainCreateLinux[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainCreateLinux]
  * to start a transient domain from the given XML.  Deprecated; use
  * conn.create_domain_xml instead.
  */
-static VALUE libvirt_conn_create_linux(int argc, VALUE *argv, VALUE c) {
+static VALUE libvirt_connect_create_linux(int argc, VALUE *argv, VALUE c)
+{
     virDomainPtr dom;
-    virConnectPtr conn = connect_get(c);
     VALUE flags, xml;
 
     rb_scan_args(argc, argv, "11", &xml, &flags);
 
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
+    dom = virDomainCreateLinux(ruby_libvirt_connect_get(c),
+                               StringValueCStr(xml),
+                               ruby_libvirt_value_to_uint(flags));
+    ruby_libvirt_raise_error_if(dom == NULL, e_Error, "virDomainCreateLinux",
+                                ruby_libvirt_connect_get(c));
 
-    dom = virDomainCreateLinux(conn, StringValueCStr(xml), NUM2UINT(flags));
-    _E(dom == NULL, create_error(e_Error, "virDomainCreateLinux", conn));
-
-    return domain_new(dom, c);
+    return ruby_libvirt_domain_new(dom, c);
 }
 
 #if HAVE_VIRDOMAINCREATEXML
@@ -983,23 +1056,22 @@ static VALUE libvirt_conn_create_linux(int argc, VALUE *argv, VALUE c) {
  * call-seq:
  *   conn.create_domain_xml(xml, flags=0) -> Libvirt::Domain
  *
- * Call +virDomainCreateXML+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainCreateXML]
+ * Call virDomainCreateXML[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainCreateXML]
  * to start a transient domain from the given XML.
  */
-static VALUE libvirt_conn_create_xml(int argc, VALUE *argv, VALUE c) {
+static VALUE libvirt_connect_create_domain_xml(int argc, VALUE *argv, VALUE c)
+{
     virDomainPtr dom;
-    virConnectPtr conn = connect_get(c);
     VALUE flags, xml;
 
     rb_scan_args(argc, argv, "11", &xml, &flags);
 
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
+    dom = virDomainCreateXML(ruby_libvirt_connect_get(c), StringValueCStr(xml),
+                             ruby_libvirt_value_to_uint(flags));
+    ruby_libvirt_raise_error_if(dom == NULL, e_Error, "virDomainCreateXML",
+                                ruby_libvirt_connect_get(c));
 
-    dom = virDomainCreateXML(conn, StringValueCStr(xml), NUM2UINT(flags));
-    _E(dom == NULL, create_error(e_Error, "virDomainCreateXML", conn));
-
-    return domain_new(dom, c);
+    return ruby_libvirt_domain_new(dom, c);
 }
 #endif
 
@@ -1007,72 +1079,78 @@ static VALUE libvirt_conn_create_xml(int argc, VALUE *argv, VALUE c) {
  * call-seq:
  *   conn.lookup_domain_by_name(name) -> Libvirt::Domain
  *
- * Call +virDomainLookupByName+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainLookupByName]
+ * Call virDomainLookupByName[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainLookupByName]
  * to retrieve a domain object for name.
  */
-static VALUE libvirt_conn_lookup_domain_by_name(VALUE c, VALUE name) {
+static VALUE libvirt_connect_lookup_domain_by_name(VALUE c, VALUE name)
+{
     virDomainPtr dom;
-    virConnectPtr conn = connect_get(c);
 
-    dom = virDomainLookupByName(conn, StringValueCStr(name));
-    _E(dom == NULL, create_error(e_RetrieveError, "virDomainLookupByName",
-                                 conn));
+    dom = virDomainLookupByName(ruby_libvirt_connect_get(c),
+                                StringValueCStr(name));
+    ruby_libvirt_raise_error_if(dom == NULL, e_RetrieveError,
+                                "virDomainLookupByName",
+                                ruby_libvirt_connect_get(c));
 
-    return domain_new(dom, c);
+    return ruby_libvirt_domain_new(dom, c);
 }
 
 /*
  * call-seq:
  *   conn.lookup_domain_by_id(id) -> Libvirt::Domain
  *
- * Call +virDomainLookupByID+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainLookupByID]
+ * Call virDomainLookupByID[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainLookupByID]
  * to retrieve a domain object for id.
  */
-static VALUE libvirt_conn_lookup_domain_by_id(VALUE c, VALUE id) {
+static VALUE libvirt_connect_lookup_domain_by_id(VALUE c, VALUE id)
+{
     virDomainPtr dom;
-    virConnectPtr conn = connect_get(c);
 
-    dom = virDomainLookupByID(conn, NUM2INT(id));
-    _E(dom == NULL, create_error(e_RetrieveError, "virDomainLookupByID",
-                                 conn));
+    dom = virDomainLookupByID(ruby_libvirt_connect_get(c), NUM2INT(id));
+    ruby_libvirt_raise_error_if(dom == NULL, e_RetrieveError,
+                                "virDomainLookupByID",
+                                ruby_libvirt_connect_get(c));
 
-    return domain_new(dom, c);
+    return ruby_libvirt_domain_new(dom, c);
 }
 
 /*
  * call-seq:
  *   conn.lookup_domain_by_uuid(uuid) -> Libvirt::Domain
  *
- * Call +virDomainLookupByUUIDString+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainLookupByUUIDString]
+ * Call virDomainLookupByUUIDString[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainLookupByUUIDString]
  * to retrieve a domain object for uuid.
  */
-static VALUE libvirt_conn_lookup_domain_by_uuid(VALUE c, VALUE uuid) {
+static VALUE libvirt_connect_lookup_domain_by_uuid(VALUE c, VALUE uuid)
+{
     virDomainPtr dom;
-    virConnectPtr conn = connect_get(c);
 
-    dom = virDomainLookupByUUIDString(conn, StringValueCStr(uuid));
-    _E(dom == NULL, create_error(e_RetrieveError, "virDomainLookupByUUID",
-                                 conn));
+    dom = virDomainLookupByUUIDString(ruby_libvirt_connect_get(c),
+                                      StringValueCStr(uuid));
+    ruby_libvirt_raise_error_if(dom == NULL, e_RetrieveError,
+                                "virDomainLookupByUUID",
+                                ruby_libvirt_connect_get(c));
 
-    return domain_new(dom, c);
+    return ruby_libvirt_domain_new(dom, c);
 }
 
 /*
  * call-seq:
  *   conn.define_domain_xml(xml) -> Libvirt::Domain
  *
- * Call +virDomainDefineXML+[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainDefineXML]
+ * Call virDomainDefineXML[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainDefineXML]
  * to define a permanent domain on this connection.
  */
-static VALUE libvirt_conn_define_domain_xml(VALUE c, VALUE xml) {
+static VALUE libvirt_connect_define_domain_xml(VALUE c, VALUE xml)
+{
     virDomainPtr dom;
-    virConnectPtr conn = connect_get(c);
 
-    dom = virDomainDefineXML(conn, StringValueCStr(xml));
-    _E(dom == NULL, create_error(e_DefinitionError, "virDomainDefineXML",
-                                 conn));
+    dom = virDomainDefineXML(ruby_libvirt_connect_get(c), StringValueCStr(xml));
+    ruby_libvirt_raise_error_if(dom == NULL, e_DefinitionError,
+                                "virDomainDefineXML",
+                                ruby_libvirt_connect_get(c));
 
-    return domain_new(dom, c);
+    return ruby_libvirt_domain_new(dom, c);
 }
 
 #if HAVE_VIRCONNECTDOMAINXMLFROMNATIVE
@@ -1080,30 +1158,22 @@ static VALUE libvirt_conn_define_domain_xml(VALUE c, VALUE xml) {
  * call-seq:
  *   conn.domain_xml_from_native(nativeFormat, xml, flags=0) -> string
  *
- * Call +virConnectDomainXMLFromNative+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectDomainXMLFromNative]
+ * Call virConnectDomainXMLFromNative[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectDomainXMLFromNative]
  * to convert a native hypervisor domain representation to libvirt XML.
  */
-static VALUE libvirt_conn_domain_xml_from_native(int argc, VALUE *argv,
-                                                 VALUE s) {
+static VALUE libvirt_connect_domain_xml_from_native(int argc, VALUE *argv,
+                                                    VALUE c)
+{
     VALUE nativeFormat, xml, flags;
-    char *ret;
-    VALUE result;
 
     rb_scan_args(argc, argv, "21", &nativeFormat, &xml, &flags);
 
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
-
-    ret = virConnectDomainXMLFromNative(conn(s), StringValueCStr(nativeFormat),
-                                        StringValueCStr(xml), NUM2UINT(flags));
-    _E(ret == NULL, create_error(e_Error, "virConnectDomainXMLFromNative",
-                                 conn(s)));
-
-    result = rb_str_new2(ret);
-
-    free(ret);
-
-    return result;
+    ruby_libvirt_generate_call_string(virConnectDomainXMLFromNative,
+                                      ruby_libvirt_connect_get(c), 1,
+                                      ruby_libvirt_connect_get(c),
+                                      StringValueCStr(nativeFormat),
+                                      StringValueCStr(xml),
+                                      ruby_libvirt_value_to_uint(flags));
 }
 #endif
 
@@ -1112,29 +1182,22 @@ static VALUE libvirt_conn_domain_xml_from_native(int argc, VALUE *argv,
  * call-seq:
  *   conn.domain_xml_to_native(nativeFormat, xml, flags=0) -> string
  *
- * Call +virConnectDomainXMLToNative+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectDomainXMLToNative]
+ * Call virConnectDomainXMLToNative[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectDomainXMLToNative]
  * to convert libvirt XML to a native domain hypervisor representation.
  */
-static VALUE libvirt_conn_domain_xml_to_native(int argc, VALUE *argv, VALUE s) {
+static VALUE libvirt_connect_domain_xml_to_native(int argc, VALUE *argv,
+                                                  VALUE c)
+{
     VALUE nativeFormat, xml, flags;
-    char *ret;
-    VALUE result;
 
     rb_scan_args(argc, argv, "21", &nativeFormat, &xml, &flags);
 
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
-
-    ret = virConnectDomainXMLToNative(conn(s), StringValueCStr(nativeFormat),
-                                      StringValueCStr(xml), NUM2UINT(flags));
-    _E(ret == NULL, create_error(e_Error, "virConnectDomainXMLToNative",
-                                 conn(s)));
-
-    result = rb_str_new2(ret);
-
-    free(ret);
-
-    return result;
+    ruby_libvirt_generate_call_string(virConnectDomainXMLToNative,
+                                      ruby_libvirt_connect_get(c), 1,
+                                      ruby_libvirt_connect_get(c),
+                                      StringValueCStr(nativeFormat),
+                                      StringValueCStr(xml),
+                                      ruby_libvirt_value_to_uint(flags));
 }
 #endif
 
@@ -1143,105 +1206,113 @@ static VALUE libvirt_conn_domain_xml_to_native(int argc, VALUE *argv, VALUE s) {
  * call-seq:
  *   conn.num_of_interfaces -> fixnum
  *
- * Call +virConnectNumOfInterfaces+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfInterfaces]
+ * Call virConnectNumOfInterfaces[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfInterfaces]
  * to retrieve the number of active interfaces on this connection.
  */
-static VALUE libvirt_conn_num_of_interfaces(VALUE s) {
-    gen_conn_num_of(s, Interfaces);
+static VALUE libvirt_connect_num_of_interfaces(VALUE c)
+{
+    gen_conn_num_of(c, Interfaces);
 }
 
 /*
  * call-seq:
  *   conn.list_interfaces -> list
  *
- * Call +virConnectListInterfaces+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListInterfaces]
+ * Call virConnectListInterfaces[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListInterfaces]
  * to retrieve a list of active interface names on this connection.
  */
-static VALUE libvirt_conn_list_interfaces(VALUE s) {
-    gen_conn_list_names(s, Interfaces);
+static VALUE libvirt_connect_list_interfaces(VALUE c)
+{
+    gen_conn_list_names(c, Interfaces);
 }
 
 /*
  * call-seq:
  *   conn.num_of_defined_interfaces -> fixnum
  *
- * Call +virConnectNumOfDefinedInterfaces+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfDefinedInterfaces]
+ * Call virConnectNumOfDefinedInterfaces[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfDefinedInterfaces]
  * to retrieve the number of inactive interfaces on this connection.
  */
-static VALUE libvirt_conn_num_of_defined_interfaces(VALUE s) {
-    gen_conn_num_of(s, DefinedInterfaces);
+static VALUE libvirt_connect_num_of_defined_interfaces(VALUE c)
+{
+    gen_conn_num_of(c, DefinedInterfaces);
 }
 
 /*
  * call-seq:
  *   conn.list_defined_interfaces -> list
  *
- * Call +virConnectListDefinedInterfaces+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListDefinedInterfaces]
+ * Call virConnectListDefinedInterfaces[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListDefinedInterfaces]
  * to retrieve a list of inactive interface names on this connection.
  */
-static VALUE libvirt_conn_list_defined_interfaces(VALUE s) {
-    gen_conn_list_names(s, DefinedInterfaces);
+static VALUE libvirt_connect_list_defined_interfaces(VALUE c)
+{
+    gen_conn_list_names(c, DefinedInterfaces);
 }
 
-extern VALUE interface_new(virInterfacePtr i, VALUE conn);
 /*
  * call-seq:
  *   conn.lookup_interface_by_name(name) -> Libvirt::Interface
  *
- * Call +virInterfaceLookupByName+[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceLookupByName]
+ * Call virInterfaceLookupByName[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceLookupByName]
  * to retrieve an interface object by name.
  */
-static VALUE libvirt_conn_lookup_interface_by_name(VALUE c, VALUE name) {
+static VALUE libvirt_connect_lookup_interface_by_name(VALUE c, VALUE name)
+{
     virInterfacePtr iface;
-    virConnectPtr conn = connect_get(c);
 
-    iface = virInterfaceLookupByName(conn, StringValueCStr(name));
-    _E(iface == NULL, create_error(e_RetrieveError, "virInterfaceLookupByName",
-                                   conn));
+    iface = virInterfaceLookupByName(ruby_libvirt_connect_get(c),
+                                     StringValueCStr(name));
+    ruby_libvirt_raise_error_if(iface == NULL, e_RetrieveError,
+                                "virInterfaceLookupByName",
+                                ruby_libvirt_connect_get(c));
 
-    return interface_new(iface, c);
+    return ruby_libvirt_interface_new(iface, c);
 }
 
 /*
  * call-seq:
  *   conn.lookup_interface_by_mac(mac) -> Libvirt::Interface
  *
- * Call +virInterfaceLookupByMACString+[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceLookupByMACString]
+ * Call virInterfaceLookupByMACString[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceLookupByMACString]
  * to retrieve an interface object by MAC address.
  */
-static VALUE libvirt_conn_lookup_interface_by_mac(VALUE c, VALUE mac) {
+static VALUE libvirt_connect_lookup_interface_by_mac(VALUE c, VALUE mac)
+{
     virInterfacePtr iface;
-    virConnectPtr conn = connect_get(c);
 
-    iface = virInterfaceLookupByMACString(conn, StringValueCStr(mac));
-    _E(iface == NULL, create_error(e_RetrieveError,
-                                   "virInterfaceLookupByMACString", conn));
+    iface = virInterfaceLookupByMACString(ruby_libvirt_connect_get(c),
+                                          StringValueCStr(mac));
+    ruby_libvirt_raise_error_if(iface == NULL, e_RetrieveError,
+                                "virInterfaceLookupByMACString",
+                                ruby_libvirt_connect_get(c));
 
-    return interface_new(iface, c);
+    return ruby_libvirt_interface_new(iface, c);
 }
 
 /*
  * call-seq:
  *   conn.define_interface_xml(xml, flags=0) -> Libvirt::Interface
  *
- * Call +virInterfaceDefineXML+[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceDefineXML]
+ * Call virInterfaceDefineXML[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceDefineXML]
  * to define a new interface from xml.
  */
-static VALUE libvirt_conn_define_interface_xml(int argc, VALUE *argv, VALUE c) {
+static VALUE libvirt_connect_define_interface_xml(int argc, VALUE *argv,
+                                                  VALUE c)
+{
     virInterfacePtr iface;
-    virConnectPtr conn = connect_get(c);
     VALUE xml, flags;
 
     rb_scan_args(argc, argv, "11", &xml, &flags);
 
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
+    iface = virInterfaceDefineXML(ruby_libvirt_connect_get(c),
+                                  StringValueCStr(xml),
+                                  ruby_libvirt_value_to_uint(flags));
+    ruby_libvirt_raise_error_if(iface == NULL, e_DefinitionError,
+                                "virInterfaceDefineXML",
+                                ruby_libvirt_connect_get(c));
 
-    iface = virInterfaceDefineXML(conn, StringValueCStr(xml), NUM2UINT(flags));
-    _E(iface == NULL, create_error(e_DefinitionError, "virInterfaceDefineXML",
-                                   conn));
-
-    return interface_new(iface, c);
+    return ruby_libvirt_interface_new(iface, c);
 }
 #endif
 
@@ -1249,139 +1320,151 @@ static VALUE libvirt_conn_define_interface_xml(int argc, VALUE *argv, VALUE c) {
  * call-seq:
  *   conn.num_of_networks -> fixnum
  *
- * Call +virConnectNumOfNetworks+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfNetworks]
+ * Call virConnectNumOfNetworks[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfNetworks]
  * to retrieve the number of active networks on this connection.
  */
-static VALUE libvirt_conn_num_of_networks(VALUE s) {
-    gen_conn_num_of(s, Networks);
+static VALUE libvirt_connect_num_of_networks(VALUE c)
+{
+    gen_conn_num_of(c, Networks);
 }
 
 /*
  * call-seq:
  *   conn.list_networks -> list
  *
- * Call +virConnectListNetworks+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListNetworks]
+ * Call virConnectListNetworks[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListNetworks]
  * to retrieve a list of active network names on this connection.
  */
-static VALUE libvirt_conn_list_networks(VALUE s) {
-    gen_conn_list_names(s, Networks);
+static VALUE libvirt_connect_list_networks(VALUE c)
+{
+    gen_conn_list_names(c, Networks);
 }
 
 /*
  * call-seq:
  *   conn.num_of_defined_networks -> fixnum
  *
- * Call +virConnectNumOfDefinedNetworks+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfDefinedNetworks]
+ * Call virConnectNumOfDefinedNetworks[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfDefinedNetworks]
  * to retrieve the number of inactive networks on this connection.
  */
-static VALUE libvirt_conn_num_of_defined_networks(VALUE s) {
-    gen_conn_num_of(s, DefinedNetworks);
+static VALUE libvirt_connect_num_of_defined_networks(VALUE c)
+{
+    gen_conn_num_of(c, DefinedNetworks);
 }
 
 /*
  * call-seq:
  *   conn.list_of_defined_networks -> list
  *
- * Call +virConnectListDefinedNetworks+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListDefinedNetworks]
+ * Call virConnectListDefinedNetworks[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListDefinedNetworks]
  * to retrieve a list of inactive network names on this connection.
  */
-static VALUE libvirt_conn_list_defined_networks(VALUE s) {
-    gen_conn_list_names(s, DefinedNetworks);
+static VALUE libvirt_connect_list_defined_networks(VALUE c)
+{
+    gen_conn_list_names(c, DefinedNetworks);
 }
 
 /*
  * call-seq:
  *   conn.lookup_network_by_name(name) -> Libvirt::Network
  *
- * Call +virNetworkLookupByName+[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkLookupByName]
+ * Call virNetworkLookupByName[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkLookupByName]
  * to retrieve a network object by name.
  */
-static VALUE libvirt_conn_lookup_network_by_name(VALUE c, VALUE name) {
+static VALUE libvirt_connect_lookup_network_by_name(VALUE c, VALUE name)
+{
     virNetworkPtr netw;
-    virConnectPtr conn = connect_get(c);
 
-    netw = virNetworkLookupByName(conn, StringValueCStr(name));
-    _E(netw == NULL, create_error(e_RetrieveError, "virNetworkLookupByName",
-                                  conn));
+    netw = virNetworkLookupByName(ruby_libvirt_connect_get(c),
+                                  StringValueCStr(name));
+    ruby_libvirt_raise_error_if(netw == NULL, e_RetrieveError,
+                                "virNetworkLookupByName",
+                                ruby_libvirt_connect_get(c));
 
-    return network_new(netw, c);
+    return ruby_libvirt_network_new(netw, c);
 }
 
 /*
  * call-seq:
  *   conn.lookup_network_by_uuid(uuid) -> Libvirt::Network
  *
- * Call +virNetworkLookupByUUIDString+[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkLookupByUUIDString]
+ * Call virNetworkLookupByUUIDString[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkLookupByUUIDString]
  * to retrieve a network object by UUID.
  */
-static VALUE libvirt_conn_lookup_network_by_uuid(VALUE c, VALUE uuid) {
+static VALUE libvirt_connect_lookup_network_by_uuid(VALUE c, VALUE uuid)
+{
     virNetworkPtr netw;
-    virConnectPtr conn = connect_get(c);
 
-    netw = virNetworkLookupByUUIDString(conn, StringValueCStr(uuid));
-    _E(netw == NULL, create_error(e_RetrieveError, "virNetworkLookupByUUID",
-                                  conn));
+    netw = virNetworkLookupByUUIDString(ruby_libvirt_connect_get(c),
+                                        StringValueCStr(uuid));
+    ruby_libvirt_raise_error_if(netw == NULL, e_RetrieveError,
+                                "virNetworkLookupByUUID",
+                                ruby_libvirt_connect_get(c));
 
-    return network_new(netw, c);
+    return ruby_libvirt_network_new(netw, c);
 }
 
 /*
  * call-seq:
  *   conn.create_network_xml(xml) -> Libvirt::Network
  *
- * Call +virNetworkCreateXML+[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkCreateXML]
+ * Call virNetworkCreateXML[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkCreateXML]
  * to start a new transient network from xml.
  */
-static VALUE libvirt_conn_create_network_xml(VALUE c, VALUE xml) {
+static VALUE libvirt_connect_create_network_xml(VALUE c, VALUE xml)
+{
     virNetworkPtr netw;
-    virConnectPtr conn = connect_get(c);
 
-    netw = virNetworkCreateXML(conn, StringValueCStr(xml));
-    _E(netw == NULL, create_error(e_Error, "virNetworkCreateXML", conn));
+    netw = virNetworkCreateXML(ruby_libvirt_connect_get(c),
+                               StringValueCStr(xml));
+    ruby_libvirt_raise_error_if(netw == NULL, e_Error, "virNetworkCreateXML",
+                                ruby_libvirt_connect_get(c));
 
-    return network_new(netw, c);
+    return ruby_libvirt_network_new(netw, c);
 }
 
 /*
  * call-seq:
  *   conn.define_network_xml(xml) -> Libvirt::Network
  *
- * Call +virNetworkDefineXML+[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkDefineXML]
+ * Call virNetworkDefineXML[http://www.libvirt.org/html/libvirt-libvirt.html#virNetworkDefineXML]
  * to define a new permanent network from xml.
  */
-static VALUE libvirt_conn_define_network_xml(VALUE c, VALUE xml) {
+static VALUE libvirt_connect_define_network_xml(VALUE c, VALUE xml)
+{
     virNetworkPtr netw;
-    virConnectPtr conn = connect_get(c);
 
-    netw = virNetworkDefineXML(conn, StringValueCStr(xml));
-    _E(netw == NULL, create_error(e_DefinitionError, "virNetworkDefineXML",
-                                  conn));
+    netw = virNetworkDefineXML(ruby_libvirt_connect_get(c),
+                               StringValueCStr(xml));
+    ruby_libvirt_raise_error_if(netw == NULL, e_DefinitionError,
+                                "virNetworkDefineXML",
+                                ruby_libvirt_connect_get(c));
 
-    return network_new(netw, c);
+    return ruby_libvirt_network_new(netw, c);
 }
 
 #if HAVE_TYPE_VIRNODEDEVICEPTR
-extern VALUE nodedevice_new(virNodeDevicePtr s, VALUE conn);
 
 /*
  * call-seq:
  *   conn.num_of_nodedevices(cap=nil, flags=0) -> fixnum
  *
- * Call +virNodeNumOfDevices+[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeNumOfDevices]
+ * Call virNodeNumOfDevices[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeNumOfDevices]
  * to retrieve the number of node devices on this connection.
  */
-static VALUE libvirt_conn_num_of_nodedevices(int argc, VALUE *argv, VALUE c) {
+static VALUE libvirt_connect_num_of_nodedevices(int argc, VALUE *argv, VALUE c)
+{
     int result;
-    virConnectPtr conn = connect_get(c);
     VALUE cap, flags;
 
     rb_scan_args(argc, argv, "02", &cap, &flags);
 
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
-
-    result = virNodeNumOfDevices(conn, get_string_or_nil(cap), NUM2UINT(flags));
-    _E(result < 0, create_error(e_RetrieveError, "virNodeNumOfDevices", conn));
+    result = virNodeNumOfDevices(ruby_libvirt_connect_get(c),
+                                 ruby_libvirt_get_cstring_or_null(cap),
+                                 ruby_libvirt_value_to_uint(flags));
+    ruby_libvirt_raise_error_if(result < 0, e_RetrieveError,
+                                "virNodeNumOfDevices",
+                                ruby_libvirt_connect_get(c));
 
     return INT2NUM(result);
 }
@@ -1390,58 +1473,61 @@ static VALUE libvirt_conn_num_of_nodedevices(int argc, VALUE *argv, VALUE c) {
  * call-seq:
  *   conn.list_nodedevices(cap=nil, flags=0) -> list
  *
- * Call +virNodeListDevices+[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeListDevices]
+ * Call virNodeListDevices[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeListDevices]
  * to retrieve a list of node device names on this connection.
  */
-static VALUE libvirt_conn_list_nodedevices(int argc, VALUE *argv, VALUE c) {
+static VALUE libvirt_connect_list_nodedevices(int argc, VALUE *argv, VALUE c)
+{
     int r, num;
-    virConnectPtr conn = connect_get(c);
-    VALUE cap, flags_val;
+    VALUE cap, flags;
     char *capstr;
     char **names;
-    unsigned int flags;
 
-    rb_scan_args(argc, argv, "02", &cap, &flags_val);
+    rb_scan_args(argc, argv, "02", &cap, &flags);
 
-    if (NIL_P(flags_val))
-        flags = 0;
-    else
-        flags = NUM2UINT(flags_val);
+    if (TYPE(flags) != T_NIL && TYPE(flags) != T_FIXNUM) {
+        rb_raise(rb_eTypeError,
+                 "wrong argument type (expected Number)");
+    }
 
-    capstr = get_string_or_nil(cap);
+    capstr = ruby_libvirt_get_cstring_or_null(cap);
 
-    num = virNodeNumOfDevices(conn, capstr, 0);
-    _E(num < 0, create_error(e_RetrieveError, "virNodeNumOfDevices", conn));
-    if (num == 0)
+    num = virNodeNumOfDevices(ruby_libvirt_connect_get(c), capstr, 0);
+    ruby_libvirt_raise_error_if(num < 0, e_RetrieveError,
+                                "virNodeNumOfDevices",
+                                ruby_libvirt_connect_get(c));
+    if (num == 0) {
         /* if num is 0, don't call virNodeListDevices function */
         return rb_ary_new2(num);
-
-    names = ALLOC_N(char *, num);
-    r = virNodeListDevices(conn, capstr, names, num, flags);
-    if (r < 0) {
-        xfree(names);
-        rb_exc_raise(create_error(e_RetrieveError, "virNodeListDevices", conn));
     }
 
-    return gen_list(num, &names);
+    names = alloca(sizeof(char *) * num);
+    r = virNodeListDevices(ruby_libvirt_connect_get(c), capstr, names, num,
+                           ruby_libvirt_value_to_uint(flags));
+    ruby_libvirt_raise_error_if(r < 0, e_RetrieveError, "virNodeListDevices",
+                                ruby_libvirt_connect_get(c));
+
+    return ruby_libvirt_generate_list(num, names);
 }
 
 /*
  * call-seq:
  *   conn.lookup_nodedevice_by_name(name) -> Libvirt::NodeDevice
  *
- * Call +virNodeDeviceLookupByName+[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeDeviceLookupByName]
+ * Call virNodeDeviceLookupByName[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeDeviceLookupByName]
  * to retrieve a nodedevice object by name.
  */
-static VALUE libvirt_conn_lookup_nodedevice_by_name(VALUE c, VALUE name) {
+static VALUE libvirt_connect_lookup_nodedevice_by_name(VALUE c, VALUE name)
+{
     virNodeDevicePtr nodedev;
-    virConnectPtr conn = connect_get(c);
 
-    nodedev = virNodeDeviceLookupByName(conn, StringValueCStr(name));
-    _E(nodedev == NULL, create_error(e_RetrieveError,
-                                     "virNodeDeviceLookupByName", conn));
+    nodedev = virNodeDeviceLookupByName(ruby_libvirt_connect_get(c),
+                                        StringValueCStr(name));
+    ruby_libvirt_raise_error_if(nodedev == NULL, e_RetrieveError,
+                                "virNodeDeviceLookupByName",
+                                ruby_libvirt_connect_get(c));
 
-    return nodedevice_new(nodedev, c);
+    return ruby_libvirt_nodedevice_new(nodedev, c);
 
 }
 
@@ -1450,194 +1536,206 @@ static VALUE libvirt_conn_lookup_nodedevice_by_name(VALUE c, VALUE name) {
  * call-seq:
  *   conn.create_nodedevice_xml(xml, flags=0) -> Libvirt::NodeDevice
  *
- * Call +virNodeDeviceCreateXML+[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeDeviceCreateXML]
+ * Call virNodeDeviceCreateXML[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeDeviceCreateXML]
  * to create a new node device from xml.
  */
-static VALUE libvirt_conn_create_nodedevice_xml(int argc, VALUE *argv,
-                                                VALUE c) {
+static VALUE libvirt_connect_create_nodedevice_xml(int argc, VALUE *argv,
+                                                   VALUE c)
+{
     virNodeDevicePtr nodedev;
-    virConnectPtr conn = connect_get(c);
     VALUE xml, flags;
 
     rb_scan_args(argc, argv, "11", &xml, &flags);
 
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
-
-    nodedev = virNodeDeviceCreateXML(conn, StringValueCStr(xml),
-                                     NUM2UINT(flags));
-    _E(nodedev == NULL, create_error(e_Error, "virNodeDeviceCreateXML", conn));
+    nodedev = virNodeDeviceCreateXML(ruby_libvirt_connect_get(c),
+                                     StringValueCStr(xml),
+                                     ruby_libvirt_value_to_uint(flags));
+    ruby_libvirt_raise_error_if(nodedev == NULL, e_Error,
+                                "virNodeDeviceCreateXML",
+                                ruby_libvirt_connect_get(c));
 
-    return nodedevice_new(nodedev, c);
+    return ruby_libvirt_nodedevice_new(nodedev, c);
 }
 #endif
 #endif
 
 #if HAVE_TYPE_VIRNWFILTERPTR
-extern VALUE nwfilter_new(virNWFilterPtr nw, VALUE conn);
 
 /*
  * call-seq:
  *   conn.num_of_nwfilters -> fixnum
  *
- * Call +virConnectNumOfNWFilters+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfNWFilters]
+ * Call virConnectNumOfNWFilters[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfNWFilters]
  * to retrieve the number of network filters on this connection.
  */
-static VALUE libvirt_conn_num_of_nwfilters(VALUE s) {
-    gen_conn_num_of(s, NWFilters);
+static VALUE libvirt_connect_num_of_nwfilters(VALUE c)
+{
+    gen_conn_num_of(c, NWFilters);
 }
 
 /*
  * call-seq:
  *   conn.list_nwfilters -> list
  *
- * Call +virConnectListNWFilters+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListNWFilters]
+ * Call virConnectListNWFilters[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListNWFilters]
  * to retrieve a list of network filter names on this connection.
  */
-static VALUE libvirt_conn_list_nwfilters(VALUE s) {
-    gen_conn_list_names(s, NWFilters);
+static VALUE libvirt_connect_list_nwfilters(VALUE c)
+{
+    gen_conn_list_names(c, NWFilters);
 }
 
 /*
  * call-seq:
  *   conn.lookup_nwfilter_by_name(name) -> Libvirt::NWFilter
  *
- * Call +virNWFilterLookupByName+[http://www.libvirt.org/html/libvirt-libvirt.html#virNWFilterLookupByName]
+ * Call virNWFilterLookupByName[http://www.libvirt.org/html/libvirt-libvirt.html#virNWFilterLookupByName]
  * to retrieve a network filter object by name.
  */
-static VALUE libvirt_conn_lookup_nwfilter_by_name(VALUE c, VALUE name) {
+static VALUE libvirt_connect_lookup_nwfilter_by_name(VALUE c, VALUE name)
+{
     virNWFilterPtr nwfilter;
-    virConnectPtr conn = connect_get(c);
 
-    nwfilter = virNWFilterLookupByName(conn, StringValueCStr(name));
-    _E(nwfilter == NULL, create_error(e_RetrieveError,
-                                      "virNWFilterLookupByName", conn));
+    nwfilter = virNWFilterLookupByName(ruby_libvirt_connect_get(c),
+                                       StringValueCStr(name));
+    ruby_libvirt_raise_error_if(nwfilter == NULL, e_RetrieveError,
+                                "virNWFilterLookupByName",
+                                ruby_libvirt_connect_get(c));
 
-    return nwfilter_new(nwfilter, c);
+    return ruby_libvirt_nwfilter_new(nwfilter, c);
 }
 
 /*
  * call-seq:
  *   conn.lookup_nwfilter_by_uuid(uuid) -> Libvirt::NWFilter
  *
- * Call +virNWFilterLookupByUUIDString+[http://www.libvirt.org/html/libvirt-libvirt.html#virNWFilterLookupByUUIDString]
+ * Call virNWFilterLookupByUUIDString[http://www.libvirt.org/html/libvirt-libvirt.html#virNWFilterLookupByUUIDString]
  * to retrieve a network filter object by UUID.
  */
-static VALUE libvirt_conn_lookup_nwfilter_by_uuid(VALUE c, VALUE uuid) {
+static VALUE libvirt_connect_lookup_nwfilter_by_uuid(VALUE c, VALUE uuid)
+{
     virNWFilterPtr nwfilter;
-    virConnectPtr conn = connect_get(c);
 
-    nwfilter = virNWFilterLookupByUUIDString(conn, StringValueCStr(uuid));
-    _E(nwfilter == NULL, create_error(e_RetrieveError,
-                                      "virNWFilterLookupByUUIDString", conn));
+    nwfilter = virNWFilterLookupByUUIDString(ruby_libvirt_connect_get(c),
+                                             StringValueCStr(uuid));
+    ruby_libvirt_raise_error_if(nwfilter == NULL, e_RetrieveError,
+                                "virNWFilterLookupByUUIDString",
+                                ruby_libvirt_connect_get(c));
 
-    return nwfilter_new(nwfilter, c);
+    return ruby_libvirt_nwfilter_new(nwfilter, c);
 }
 
 /*
  * call-seq:
  *   conn.define_nwfilter_xml(xml) -> Libvirt::NWFilter
  *
- * Call +virNWFilterDefineXML+[http://www.libvirt.org/html/libvirt-libvirt.html#virNWFilterDefineXML]
+ * Call virNWFilterDefineXML[http://www.libvirt.org/html/libvirt-libvirt.html#virNWFilterDefineXML]
  * to define a new network filter from xml.
  */
-static VALUE libvirt_conn_define_nwfilter_xml(VALUE c, VALUE xml) {
+static VALUE libvirt_connect_define_nwfilter_xml(VALUE c, VALUE xml)
+{
     virNWFilterPtr nwfilter;
-    virConnectPtr conn = connect_get(c);
 
-    nwfilter = virNWFilterDefineXML(conn, StringValueCStr(xml));
-    _E(nwfilter == NULL, create_error(e_DefinitionError, "virNWFilterDefineXML",
-                                      conn));
+    nwfilter = virNWFilterDefineXML(ruby_libvirt_connect_get(c),
+                                    StringValueCStr(xml));
+    ruby_libvirt_raise_error_if(nwfilter == NULL, e_DefinitionError,
+                                "virNWFilterDefineXML",
+                                ruby_libvirt_connect_get(c));
 
-    return nwfilter_new(nwfilter, c);
+    return ruby_libvirt_nwfilter_new(nwfilter, c);
 }
 #endif
 
 #if HAVE_TYPE_VIRSECRETPTR
-extern VALUE secret_new(virSecretPtr s, VALUE conn);
 
 /*
  * call-seq:
  *   conn.num_of_secrets -> fixnum
  *
- * Call +virConnectNumOfSecrets+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfSecrets]
+ * Call virConnectNumOfSecrets[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfSecrets]
  * to retrieve the number of secrets on this connection.
  */
-static VALUE libvirt_conn_num_of_secrets(VALUE s) {
-    gen_conn_num_of(s, Secrets);
+static VALUE libvirt_connect_num_of_secrets(VALUE c)
+{
+    gen_conn_num_of(c, Secrets);
 }
 
 /*
  * call-seq:
  *   conn.list_secrets -> list
  *
- * Call +virConnectListSecrets+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListSecrets]
+ * Call virConnectListSecrets[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListSecrets]
  * to retrieve a list of secret UUIDs on this connection.
  */
-static VALUE libvirt_conn_list_secrets(VALUE s) {
-    gen_conn_list_names(s, Secrets);
+static VALUE libvirt_connect_list_secrets(VALUE c)
+{
+    gen_conn_list_names(c, Secrets);
 }
 
 /*
  * call-seq:
  *   conn.lookup_secret_by_uuid(uuid) -> Libvirt::Secret
  *
- * Call +virSecretLookupByUUID+[http://www.libvirt.org/html/libvirt-libvirt.html#virSecretLookupByUUID]
+ * Call virSecretLookupByUUID[http://www.libvirt.org/html/libvirt-libvirt.html#virSecretLookupByUUID]
  * to retrieve a network object from uuid.
  */
-static VALUE libvirt_conn_lookup_secret_by_uuid(VALUE c, VALUE uuid) {
+static VALUE libvirt_connect_lookup_secret_by_uuid(VALUE c, VALUE uuid)
+{
     virSecretPtr secret;
-    virConnectPtr conn = connect_get(c);
 
-    secret = virSecretLookupByUUIDString(conn, StringValueCStr(uuid));
-    _E(secret == NULL, create_error(e_RetrieveError, "virSecretLookupByUUID",
-                                    conn));
+    secret = virSecretLookupByUUIDString(ruby_libvirt_connect_get(c),
+                                         StringValueCStr(uuid));
+    ruby_libvirt_raise_error_if(secret == NULL, e_RetrieveError,
+                                "virSecretLookupByUUID",
+                                ruby_libvirt_connect_get(c));
 
-    return secret_new(secret, c);
+    return ruby_libvirt_secret_new(secret, c);
 }
 
 /*
  * call-seq:
  *   conn.lookup_secret_by_usage(usagetype, usageID) -> Libvirt::Secret
  *
- * Call +virSecretLookupByUsage+[http://www.libvirt.org/html/libvirt-libvirt.html#virSecretLookupByUsage]
+ * Call virSecretLookupByUsage[http://www.libvirt.org/html/libvirt-libvirt.html#virSecretLookupByUsage]
  * to retrieve a secret by usagetype.
  */
-static VALUE libvirt_conn_lookup_secret_by_usage(VALUE c, VALUE usagetype,
-                                                 VALUE usageID) {
+static VALUE libvirt_connect_lookup_secret_by_usage(VALUE c, VALUE usagetype,
+                                                    VALUE usageID)
+{
     virSecretPtr secret;
-    virConnectPtr conn = connect_get(c);
 
-    secret = virSecretLookupByUsage(conn, NUM2UINT(usagetype),
+    secret = virSecretLookupByUsage(ruby_libvirt_connect_get(c),
+                                    NUM2UINT(usagetype),
                                     StringValueCStr(usageID));
-    _E(secret == NULL, create_error(e_RetrieveError, "virSecretLookupByUsage",
-                                    conn));
+    ruby_libvirt_raise_error_if(secret == NULL, e_RetrieveError,
+                                "virSecretLookupByUsage",
+                                ruby_libvirt_connect_get(c));
 
-    return secret_new(secret, c);
+    return ruby_libvirt_secret_new(secret, c);
 }
 
 /*
  * call-seq:
  *   conn.define_secret_xml(xml, flags=0) -> Libvirt::Secret
  *
- * Call +virSecretDefineXML+[http://www.libvirt.org/html/libvirt-libvirt.html#virSecretDefineXML]
+ * Call virSecretDefineXML[http://www.libvirt.org/html/libvirt-libvirt.html#virSecretDefineXML]
  * to define a new secret from xml.
  */
-static VALUE libvirt_conn_define_secret_xml(int argc, VALUE *argv, VALUE c) {
+static VALUE libvirt_connect_define_secret_xml(int argc, VALUE *argv, VALUE c)
+{
     virSecretPtr secret;
-    virConnectPtr conn = connect_get(c);
     VALUE xml, flags;
 
     rb_scan_args(argc, argv, "11", &xml, &flags);
 
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
+    secret = virSecretDefineXML(ruby_libvirt_connect_get(c),
+                                StringValueCStr(xml),
+                                ruby_libvirt_value_to_uint(flags));
+    ruby_libvirt_raise_error_if(secret == NULL, e_DefinitionError,
+                                "virSecretDefineXML",
+                                ruby_libvirt_connect_get(c));
 
-    secret = virSecretDefineXML(conn, StringValueCStr(xml), NUM2UINT(flags));
-    _E(secret == NULL, create_error(e_DefinitionError, "virSecretDefineXML",
-                                    conn));
-
-    return secret_new(secret, c);
+    return ruby_libvirt_secret_new(secret, c);
 }
 #endif
 
@@ -1649,60 +1747,66 @@ VALUE pool_new(virStoragePoolPtr n, VALUE conn);
  * call-seq:
  *   conn.list_storage_pools -> list
  *
- * Call +virConnectListStoragePools+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListStoragePools]
+ * Call virConnectListStoragePools[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListStoragePools]
  * to retrieve a list of active storage pool names on this connection.
  */
-static VALUE libvirt_conn_list_storage_pools(VALUE s) {
-    gen_conn_list_names(s, StoragePools);
+static VALUE libvirt_connect_list_storage_pools(VALUE c)
+{
+    gen_conn_list_names(c, StoragePools);
 }
 
 /*
  * call-seq:
  *   conn.num_of_storage_pools -> fixnum
  *
- * Call +virConnectNumOfStoragePools+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfStoragePools]
+ * Call virConnectNumOfStoragePools[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfStoragePools]
  * to retrieve the number of active storage pools on this connection.
  */
-static VALUE libvirt_conn_num_of_storage_pools(VALUE s) {
-    gen_conn_num_of(s, StoragePools);
+static VALUE libvirt_connect_num_of_storage_pools(VALUE c)
+{
+    gen_conn_num_of(c, StoragePools);
 }
 
 /*
  * call-seq:
  *   conn.list_defined_storage_pools -> list
  *
- * Call +virConnectListDefinedStoragePools+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListDefinedStoragePools]
+ * Call virConnectListDefinedStoragePools[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListDefinedStoragePools]
  * to retrieve a list of inactive storage pool names on this connection.
  */
-static VALUE libvirt_conn_list_defined_storage_pools(VALUE s) {
-    gen_conn_list_names(s, DefinedStoragePools);
+static VALUE libvirt_connect_list_defined_storage_pools(VALUE c)
+{
+    gen_conn_list_names(c, DefinedStoragePools);
 }
 
 /*
  * call-seq:
  *   conn.num_of_defined_storage_pools -> fixnum
  *
- * Call +virConnectNumOfDefinedStoragePools+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfDefinedStoragePools]
+ * Call virConnectNumOfDefinedStoragePools[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectNumOfDefinedStoragePools]
  * to retrieve the number of inactive storage pools on this connection.
  */
-static VALUE libvirt_conn_num_of_defined_storage_pools(VALUE s) {
-    gen_conn_num_of(s, DefinedStoragePools);
+static VALUE libvirt_connect_num_of_defined_storage_pools(VALUE c)
+{
+    gen_conn_num_of(c, DefinedStoragePools);
 }
 
 /*
  * call-seq:
  *   conn.lookup_storage_pool_by_name(name) -> Libvirt::StoragePool
  *
- * Call +virStoragePoolLookupByName+[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolLookupByName]
+ * Call virStoragePoolLookupByName[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolLookupByName]
  * to retrieve a storage pool object by name.
  */
-static VALUE libvirt_conn_lookup_pool_by_name(VALUE c, VALUE name) {
+static VALUE libvirt_connect_lookup_pool_by_name(VALUE c, VALUE name)
+{
     virStoragePoolPtr pool;
-    virConnectPtr conn = connect_get(c);
 
-    pool = virStoragePoolLookupByName(conn, StringValueCStr(name));
-    _E(pool == NULL, create_error(e_RetrieveError, "virStoragePoolLookupByName",
-                                  conn));
+    pool = virStoragePoolLookupByName(ruby_libvirt_connect_get(c),
+                                      StringValueCStr(name));
+    ruby_libvirt_raise_error_if(pool == NULL, e_RetrieveError,
+                                "virStoragePoolLookupByName",
+                                ruby_libvirt_connect_get(c));
 
     return pool_new(pool, c);
 }
@@ -1711,16 +1815,18 @@ static VALUE libvirt_conn_lookup_pool_by_name(VALUE c, VALUE name) {
  * call-seq:
  *   conn.lookup_storage_pool_by_uuid(uuid) -> Libvirt::StoragePool
  *
- * Call +virStoragePoolLookupByUUIDString+[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolLookupByUUIDString]
+ * Call virStoragePoolLookupByUUIDString[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolLookupByUUIDString]
  * to retrieve a storage pool object by uuid.
  */
-static VALUE libvirt_conn_lookup_pool_by_uuid(VALUE c, VALUE uuid) {
+static VALUE libvirt_connect_lookup_pool_by_uuid(VALUE c, VALUE uuid)
+{
     virStoragePoolPtr pool;
-    virConnectPtr conn = connect_get(c);
 
-    pool = virStoragePoolLookupByUUIDString(conn, StringValueCStr(uuid));
-    _E(pool == NULL, create_error(e_RetrieveError, "virStoragePoolLookupByUUID",
-                                  conn));
+    pool = virStoragePoolLookupByUUIDString(ruby_libvirt_connect_get(c),
+                                            StringValueCStr(uuid));
+    ruby_libvirt_raise_error_if(pool == NULL, e_RetrieveError,
+                                "virStoragePoolLookupByUUID",
+                                ruby_libvirt_connect_get(c));
 
     return pool_new(pool, c);
 }
@@ -1729,21 +1835,22 @@ static VALUE libvirt_conn_lookup_pool_by_uuid(VALUE c, VALUE uuid) {
  * call-seq:
  *   conn.create_storage_pool_xml(xml, flags=0) -> Libvirt::StoragePool
  *
- * Call +virStoragePoolCreateXML+[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolCreateXML]
+ * Call virStoragePoolCreateXML[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolCreateXML]
  * to start a new transient storage pool from xml.
  */
-static VALUE libvirt_conn_create_pool_xml(int argc, VALUE *argv, VALUE c) {
+static VALUE libvirt_connect_create_pool_xml(int argc, VALUE *argv, VALUE c)
+{
     virStoragePoolPtr pool;
-    virConnectPtr conn = connect_get(c);
     VALUE xml, flags;
 
     rb_scan_args(argc, argv, "11", &xml, &flags);
 
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
-
-    pool = virStoragePoolCreateXML(conn, StringValueCStr(xml), NUM2UINT(flags));
-    _E(pool == NULL, create_error(e_Error, "virStoragePoolCreateXML", conn));
+    pool = virStoragePoolCreateXML(ruby_libvirt_connect_get(c),
+                                   StringValueCStr(xml),
+                                   ruby_libvirt_value_to_uint(flags));
+    ruby_libvirt_raise_error_if(pool == NULL, e_Error,
+                                "virStoragePoolCreateXML",
+                                ruby_libvirt_connect_get(c));
 
     return pool_new(pool, c);
 }
@@ -1752,22 +1859,22 @@ static VALUE libvirt_conn_create_pool_xml(int argc, VALUE *argv, VALUE c) {
  * call-seq:
  *   conn.define_storage_pool_xml(xml, flags=0) -> Libvirt::StoragePool
  *
- * Call +virStoragePoolDefineXML+[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolDefineXML]
+ * Call virStoragePoolDefineXML[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolDefineXML]
  * to define a permanent storage pool from xml.
  */
-static VALUE libvirt_conn_define_pool_xml(int argc, VALUE *argv, VALUE c) {
+static VALUE libvirt_connect_define_pool_xml(int argc, VALUE *argv, VALUE c)
+{
     virStoragePoolPtr pool;
-    virConnectPtr conn = connect_get(c);
     VALUE xml, flags;
 
     rb_scan_args(argc, argv, "11", &xml, &flags);
 
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
-
-    pool = virStoragePoolDefineXML(conn, StringValueCStr(xml), NUM2UINT(flags));
-    _E(pool == NULL, create_error(e_DefinitionError, "virStoragePoolDefineXML",
-                                  conn));
+    pool = virStoragePoolDefineXML(ruby_libvirt_connect_get(c),
+                                   StringValueCStr(xml),
+                                   ruby_libvirt_value_to_uint(flags));
+    ruby_libvirt_raise_error_if(pool == NULL, e_DefinitionError,
+                                "virStoragePoolDefineXML",
+                                ruby_libvirt_connect_get(c));
 
     return pool_new(pool, c);
 }
@@ -1776,21 +1883,22 @@ static VALUE libvirt_conn_define_pool_xml(int argc, VALUE *argv, VALUE c) {
  * call-seq:
  *   conn.discover_storage_pool_sources(type, srcSpec=nil, flags=0) -> string
  *
- * Call +virConnectFindStoragePoolSources+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectFindStoragePoolSources]
+ * Call virConnectFindStoragePoolSources[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectFindStoragePoolSources]
  * to find the storage pool sources corresponding to type.
  */
-static VALUE libvirt_conn_find_storage_pool_sources(int argc, VALUE *argv,
-                                                    VALUE c) {
-    VALUE type, srcSpec_val, flags;
-
-    rb_scan_args(argc, argv, "12", &type, &srcSpec_val, &flags);
+static VALUE libvirt_connect_find_storage_pool_sources(int argc, VALUE *argv,
+                                                       VALUE c)
+{
+    VALUE type, srcSpec, flags;
 
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
+    rb_scan_args(argc, argv, "12", &type, &srcSpec, &flags);
 
-    gen_call_string(virConnectFindStoragePoolSources, conn(c), 1,
-                    connect_get(c), StringValueCStr(type),
-                    get_string_or_nil(srcSpec_val), NUM2UINT(flags));
+    ruby_libvirt_generate_call_string(virConnectFindStoragePoolSources,
+                                      ruby_libvirt_connect_get(c), 1,
+                                      ruby_libvirt_connect_get(c),
+                                      StringValueCStr(type),
+                                      ruby_libvirt_get_cstring_or_null(srcSpec),
+                                      ruby_libvirt_value_to_uint(flags));
 }
 #endif
 
@@ -1799,47 +1907,46 @@ static VALUE libvirt_conn_find_storage_pool_sources(int argc, VALUE *argv,
  * call-seq:
  *   conn.sys_info(flags=0) -> string
  *
- * Call +virConnectGetSysinfo+[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectGetSysinfo]
+ * Call virConnectGetSysinfo[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectGetSysinfo]
  * to get machine-specific information about the hypervisor.  This may include
  * data such as the host UUID, the BIOS version, etc.
  */
-static VALUE libvirt_conn_get_sys_info(int argc, VALUE *argv, VALUE c) {
+static VALUE libvirt_connect_sys_info(int argc, VALUE *argv, VALUE c)
+{
     VALUE flags;
 
     rb_scan_args(argc, argv, "01", &flags);
 
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
-
-    gen_call_string(virConnectGetSysinfo, conn(c), 1, connect_get(c),
-                    NUM2UINT(flags));
+    ruby_libvirt_generate_call_string(virConnectGetSysinfo,
+                                      ruby_libvirt_connect_get(c), 1,
+                                      ruby_libvirt_connect_get(c),
+                                      ruby_libvirt_value_to_uint(flags));
 }
 #endif
 
 #if HAVE_TYPE_VIRSTREAMPTR
-extern VALUE stream_new(virStreamPtr s, VALUE conn);
 
 /*
  * call-seq:
  *   conn.stream(flags=0) -> Libvirt::Stream
  *
- * Call +virStreamNew+[http://www.libvirt.org/html/libvirt-libvirt.html#virStreamNew]
+ * Call virStreamNew[http://www.libvirt.org/html/libvirt-libvirt.html#virStreamNew]
  * to create a new stream.
  */
-static VALUE libvirt_conn_stream(int argc, VALUE *argv, VALUE c) {
+static VALUE libvirt_connect_stream(int argc, VALUE *argv, VALUE c)
+{
     VALUE flags;
     virStreamPtr stream;
 
     rb_scan_args(argc, argv, "01", &flags);
 
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
+    stream = virStreamNew(ruby_libvirt_connect_get(c),
+                          ruby_libvirt_value_to_uint(flags));
 
-    stream = virStreamNew(connect_get(c), NUM2UINT(flags));
+    ruby_libvirt_raise_error_if(stream == NULL, e_RetrieveError,
+                                "virStreamNew", ruby_libvirt_connect_get(c));
 
-    _E(stream == NULL, create_error(e_RetrieveError, "virStreamNew", conn(c)));
-
-    return stream_new(stream, c);
+    return ruby_libvirt_stream_new(stream, c);
 }
 #endif
 
@@ -1848,111 +1955,787 @@ static VALUE libvirt_conn_stream(int argc, VALUE *argv, VALUE c) {
  * call-seq:
  *   conn.interface_change_begin(flags=0) -> nil
  *
- * Call +virInterfaceChangeBegin+[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceChangeBegin]
+ * Call virInterfaceChangeBegin[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceChangeBegin]
  * to create a restore point for interface changes.  Once changes have been
  * made, conn.interface_change_commit can be used to commit the result or
  * conn.interface_change_rollback can be used to rollback to this restore point.
  */
-static VALUE libvirt_conn_interface_change_begin(int argc, VALUE *argv,
-                                                 VALUE c) {
+static VALUE libvirt_connect_interface_change_begin(int argc, VALUE *argv,
+                                                    VALUE c)
+{
     VALUE flags;
 
     rb_scan_args(argc, argv, "01", &flags);
 
-    gen_call_void(virInterfaceChangeBegin, conn(c), connect_get(c),
-                  NUM2UINT(flags));
+    ruby_libvirt_generate_call_nil(virInterfaceChangeBegin,
+                                   ruby_libvirt_connect_get(c),
+                                   ruby_libvirt_connect_get(c),
+                                   ruby_libvirt_value_to_uint(flags));
 }
 
 /*
  * call-seq:
  *   conn.interface_change_commit(flags=0) -> nil
  *
- * Call +virInterfaceChangeCommit+[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceChangeCommit]
+ * Call virInterfaceChangeCommit[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceChangeCommit]
  * to commit the interface changes since the last conn.interface_change_begin.
  */
-static VALUE libvirt_conn_interface_change_commit(int argc, VALUE *argv,
-                                                  VALUE c) {
+static VALUE libvirt_connect_interface_change_commit(int argc, VALUE *argv,
+                                                     VALUE c)
+{
     VALUE flags;
 
     rb_scan_args(argc, argv, "01", &flags);
 
-    gen_call_void(virInterfaceChangeCommit, conn(c), connect_get(c),
-                  NUM2UINT(flags));
+    ruby_libvirt_generate_call_nil(virInterfaceChangeCommit,
+                                   ruby_libvirt_connect_get(c),
+                                   ruby_libvirt_connect_get(c),
+                                   ruby_libvirt_value_to_uint(flags));
 }
 
 /*
  * call-seq:
  *   conn.interface_change_rollback(flags=0) -> nil
  *
- * Call +virInterfaceChangeRollback+[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceChangeRollback]
+ * Call virInterfaceChangeRollback[http://www.libvirt.org/html/libvirt-libvirt.html#virInterfaceChangeRollback]
  * to rollback to the restore point saved by conn.interface_change_begin.
  */
-static VALUE libvirt_conn_interface_change_rollback(int argc, VALUE *argv,
-                                                    VALUE c) {
+static VALUE libvirt_connect_interface_change_rollback(int argc, VALUE *argv,
+                                                       VALUE c)
+{
     VALUE flags;
 
     rb_scan_args(argc, argv, "01", &flags);
 
-    gen_call_void(virInterfaceChangeRollback, conn(c), connect_get(c),
-                  NUM2UINT(flags));
+    ruby_libvirt_generate_call_nil(virInterfaceChangeRollback,
+                                   ruby_libvirt_connect_get(c),
+                                   ruby_libvirt_connect_get(c),
+                                   ruby_libvirt_value_to_uint(flags));
 }
 #endif
 
+#if HAVE_VIRNODEGETCPUSTATS
+static void cpu_stats_set(void *voidparams, int i, VALUE result)
+{
+    virNodeCPUStatsPtr params = (virNodeCPUStatsPtr)voidparams;
+
+    rb_hash_aset(result, rb_str_new2(params[i].field),
+                 ULL2NUM(params[i].value));
+}
+
+static char *cpu_stats_nparams(VALUE d, unsigned int flags, void *opaque,
+                               int *nparams)
+{
+    int intparam = *((int *)opaque);
+
+    if (virNodeGetCPUStats(ruby_libvirt_connect_get(d), intparam, NULL,
+                           nparams, flags) < 0) {
+        return "virNodeGetCPUStats";
+    }
+
+    return NULL;
+}
+
+static char *cpu_stats_get(VALUE d, unsigned int flags, void *voidparams,
+                           int *nparams, void *opaque)
+{
+    int intparam = *((int *)opaque);
+    virNodeCPUStatsPtr params = (virNodeCPUStatsPtr)voidparams;
+
+    if (virNodeGetCPUStats(ruby_libvirt_connect_get(d), intparam, params,
+                           nparams, flags) < 0) {
+        return "virNodeGetCPUStats";
+    }
+
+    return NULL;
+}
+
 /*
- * Class Libvirt::Connect
+ * call-seq:
+ *   conn.node_cpu_stats(cpuNum=-1, flags=0) -> Hash
+ *
+ * Call virNodeGetCPUStats[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeGetCPUStats]
+ * to retrieve cpu statistics from the virtualization host.
  */
-void init_connect()
+static VALUE libvirt_connect_node_cpu_stats(int argc, VALUE *argv, VALUE c)
 {
-    c_connect = rb_define_class_under(m_libvirt, "Connect", rb_cObject);
+    VALUE intparam, flags;
+    int tmp;
 
-    /*
-     * Class Libvirt::Connect::Nodeinfo
-     */
-    c_node_info = rb_define_class_under(c_connect, "Nodeinfo", rb_cObject);
-    rb_define_attr(c_node_info, "model", 1, 0);
-    rb_define_attr(c_node_info, "memory", 1, 0);
-    rb_define_attr(c_node_info, "cpus", 1, 0);
-    rb_define_attr(c_node_info, "mhz", 1, 0);
-    rb_define_attr(c_node_info, "nodes", 1, 0);
-    rb_define_attr(c_node_info, "sockets", 1, 0);
-    rb_define_attr(c_node_info, "cores", 1, 0);
-    rb_define_attr(c_node_info, "threads", 1, 0);
+    rb_scan_args(argc, argv, "02", &intparam, &flags);
 
-    /*
-     * Class Libvirt::Connect::NodeSecurityModel
-     */
-    c_node_security_model = rb_define_class_under(c_connect,
-                                                  "NodeSecurityModel",
-                                                  rb_cObject);
-    rb_define_attr(c_node_security_model, "model", 1, 0);
-    rb_define_attr(c_node_security_model, "doi", 1, 0);
+    tmp = ruby_libvirt_value_to_int(intparam);
 
-    rb_define_method(c_connect, "close", libvirt_conn_close, 0);
-    rb_define_method(c_connect, "closed?", libvirt_conn_closed_p, 0);
-    rb_define_method(c_connect, "type", libvirt_conn_type, 0);
-    rb_define_method(c_connect, "version", libvirt_conn_version, 0);
-#if HAVE_VIRCONNECTGETLIBVERSION
-    rb_define_method(c_connect, "libversion", libvirt_conn_libversion, 0);
-#endif
-    rb_define_method(c_connect, "hostname", libvirt_conn_hostname, 0);
-    rb_define_method(c_connect, "uri", libvirt_conn_uri, 0);
-    rb_define_method(c_connect, "max_vcpus", libvirt_conn_max_vcpus, -1);
-    rb_define_method(c_connect, "node_get_info", libvirt_conn_node_get_info, 0);
-    rb_define_method(c_connect, "node_free_memory",
-                     libvirt_conn_node_free_memory, 0);
-    rb_define_method(c_connect, "node_cells_free_memory",
-                     libvirt_conn_node_cells_free_memory, -1);
-#if HAVE_VIRNODEGETSECURITYMODEL
-    rb_define_method(c_connect, "node_get_security_model",
-                     libvirt_conn_node_get_security_model, 0);
-#endif
-#if HAVE_VIRCONNECTISENCRYPTED
-    rb_define_method(c_connect, "encrypted?", libvirt_conn_encrypted_p, 0);
-#endif
-#if HAVE_VIRCONNECTISSECURE
-    rb_define_method(c_connect, "secure?", libvirt_conn_secure_p, 0);
+    return ruby_libvirt_get_parameters(c, ruby_libvirt_value_to_uint(flags),
+                                       (void *)&tmp, sizeof(virNodeCPUStats),
+                                       cpu_stats_nparams, cpu_stats_get,
+                                       cpu_stats_set);
+}
 #endif
-    rb_define_method(c_connect, "capabilities", libvirt_conn_capabilities, 0);
+
+#if HAVE_VIRNODEGETMEMORYSTATS
+static void memory_stats_set(void *voidparams, int i, VALUE result)
+{
+    virNodeMemoryStatsPtr params = (virNodeMemoryStatsPtr)voidparams;
+
+    rb_hash_aset(result, rb_str_new2(params[i].field),
+                 ULL2NUM(params[i].value));
+}
+
+static char *memory_stats_nparams(VALUE d, unsigned int flags, void *opaque,
+                                  int *nparams)
+{
+    int intparam = *((int *)opaque);
+
+    if (virNodeGetMemoryStats(ruby_libvirt_connect_get(d), intparam, NULL,
+                              nparams, flags) < 0) {
+        return "virNodeGetMemoryStats";
+    }
+
+    return NULL;
+}
+
+static char *memory_stats_get(VALUE d, unsigned int flags, void *voidparams,
+                              int *nparams, void *opaque)
+{
+    int intparam = *((int *)opaque);
+    virNodeMemoryStatsPtr params = (virNodeMemoryStatsPtr)voidparams;
+
+    if (virNodeGetMemoryStats(ruby_libvirt_connect_get(d), intparam, params,
+                           nparams, flags) < 0) {
+        return "virNodeGetMemoryStats";
+    }
+
+    return NULL;
+}
+
+/*
+ * call-seq:
+ *   conn.node_memory_stats(cellNum=-1, flags=0) -> Hash
+ *
+ * Call virNodeGetMemoryStats[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeGetMemoryStats]
+ * to retrieve memory statistics from the virtualization host.
+ */
+static VALUE libvirt_connect_node_memory_stats(int argc, VALUE *argv, VALUE c)
+{
+    VALUE intparam, flags;
+    int tmp;
+
+    rb_scan_args(argc, argv, "02", &intparam, &flags);
+
+    tmp = ruby_libvirt_value_to_int(intparam);
+
+    return ruby_libvirt_get_parameters(c, ruby_libvirt_value_to_uint(flags),
+                                       (void *)&tmp, sizeof(virNodeMemoryStats),
+                                       memory_stats_nparams, memory_stats_get,
+                                       memory_stats_set);
+}
+#endif
+
+#if HAVE_VIRDOMAINSAVEIMAGEGETXMLDESC
+/*
+ * call-seq:
+ *   conn.save_image_xml_desc(filename, flags=0) -> string
+ *
+ * Call virDomainSaveImageGetXMLDesc[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainSaveImageGetXMLDesc]
+ * to get the XML corresponding to a save file.
+ */
+static VALUE libvirt_connect_save_image_xml_desc(int argc, VALUE *argv, VALUE c)
+{
+    VALUE filename, flags;
+
+    rb_scan_args(argc, argv, "11", &filename, &flags);
+
+    ruby_libvirt_generate_call_string(virDomainSaveImageGetXMLDesc,
+                                      ruby_libvirt_connect_get(c), 1,
+                                      ruby_libvirt_connect_get(c),
+                                      StringValueCStr(filename),
+                                      ruby_libvirt_value_to_uint(flags));
+}
+
+/*
+ * call-seq:
+ *   conn.define_save_image_xml(filename, newxml, flags=0) -> nil
+ *
+ * Call virDomainSaveImageDefineXML[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainSaveImageDefineXML]
+ * to define new XML for a saved image.
+ */
+static VALUE libvirt_connect_define_save_image_xml(int argc, VALUE *argv,
+                                                   VALUE c)
+{
+    VALUE filename, newxml, flags;
+
+    rb_scan_args(argc, argv, "21", &filename, &newxml, &flags);
+
+    ruby_libvirt_generate_call_nil(virDomainSaveImageDefineXML,
+                                   ruby_libvirt_connect_get(c),
+                                   ruby_libvirt_connect_get(c),
+                                   StringValueCStr(filename),
+                                   StringValueCStr(newxml),
+                                   ruby_libvirt_value_to_uint(flags));
+}
+#endif
+
+#if HAVE_VIRNODESUSPENDFORDURATION
+/*
+ * call-seq:
+ *   conn.node_suspend_for_duration(target, duration, flags=0) -> nil
+ *
+ * Call virNodeSuspendForDuration[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeSuspendForDuration]
+ * to suspend the hypervisor for the specified duration.
+ */
+static VALUE libvirt_connect_node_suspend_for_duration(int argc, VALUE *argv,
+                                                       VALUE c)
+{
+    VALUE target, duration, flags;
+
+    rb_scan_args(argc, argv, "21", &target, &duration, &flags);
+
+    ruby_libvirt_generate_call_nil(virNodeSuspendForDuration,
+                                   ruby_libvirt_connect_get(c),
+                                   ruby_libvirt_connect_get(c),
+                                   NUM2UINT(target), NUM2ULL(duration),
+                                   ruby_libvirt_value_to_uint(flags));
+}
+#endif
+
+#if HAVE_VIRNODEGETMEMORYPARAMETERS
+static char *node_memory_nparams(VALUE d, unsigned int flags, void *opaque,
+                                 int *nparams)
+{
+    if (virNodeGetMemoryParameters(ruby_libvirt_connect_get(d), NULL, nparams,
+                                   flags) < 0) {
+        return "virNodeGetMemoryParameters";
+    }
+
+    return NULL;
+}
+
+static char *node_memory_get(VALUE d, unsigned int flags, void *voidparams,
+                             int *nparams, void *opaque)
+{
+    virTypedParameterPtr params = (virTypedParameterPtr)voidparams;
+
+    if (virNodeGetMemoryParameters(ruby_libvirt_connect_get(d), params, nparams,
+                                   flags) < 0) {
+        return "virNodeGetMemoryParameters";
+    }
+    return NULL;
+}
+
+static char *node_memory_set(VALUE d, unsigned int flags,
+                             virTypedParameterPtr params, int nparams,
+                             void *opauqe)
+{
+    if (virNodeSetMemoryParameters(ruby_libvirt_connect_get(d), params, nparams,
+                                   flags) < 0) {
+        return "virNodeSetMemoryParameters";
+    }
+    return NULL;
+}
+
+/*
+ * call-seq:
+ *   conn.node_memory_parameters(flags=0) -> Hash
+ *
+ * Call virNodeGetMemoryParameters[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeGetMemoryParameters]
+ * to get information about memory on the host node.
+ */
+static VALUE libvirt_connect_node_memory_parameters(int argc, VALUE *argv,
+                                                    VALUE c)
+{
+    VALUE flags;
+
+    rb_scan_args(argc, argv, "01", &flags);
+
+    return ruby_libvirt_get_typed_parameters(c,
+                                             ruby_libvirt_value_to_uint(flags),
+                                             NULL, node_memory_nparams,
+                                             node_memory_get);
+}
+
+static struct ruby_libvirt_typed_param memory_allowed[] = {
+    {VIR_NODE_MEMORY_SHARED_PAGES_TO_SCAN, VIR_TYPED_PARAM_UINT},
+    {VIR_NODE_MEMORY_SHARED_SLEEP_MILLISECS, VIR_TYPED_PARAM_UINT},
+    {VIR_NODE_MEMORY_SHARED_PAGES_SHARED, VIR_TYPED_PARAM_ULLONG},
+    {VIR_NODE_MEMORY_SHARED_PAGES_SHARING, VIR_TYPED_PARAM_ULLONG},
+    {VIR_NODE_MEMORY_SHARED_PAGES_UNSHARED, VIR_TYPED_PARAM_ULLONG},
+    {VIR_NODE_MEMORY_SHARED_PAGES_VOLATILE, VIR_TYPED_PARAM_ULLONG},
+    {VIR_NODE_MEMORY_SHARED_FULL_SCANS, VIR_TYPED_PARAM_ULLONG},
+#if HAVE_CONST_VIR_NODE_MEMORY_SHARED_MERGE_ACROSS_NODES
+    {VIR_NODE_MEMORY_SHARED_MERGE_ACROSS_NODES, VIR_TYPED_PARAM_UINT},
+#endif
+};
+
+/*
+ * call-seq:
+ *   conn.node_memory_parameters = Hash,flags=0
+ *
+ * Call virNodeSetMemoryParameters[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeSetMemoryParameters]
+ * to set the memory parameters for this host node.
+ */
+static VALUE libvirt_connect_node_memory_parameters_equal(VALUE c, VALUE input)
+{
+    VALUE hash, flags;
+
+    ruby_libvirt_assign_hash_and_flags(input, &hash, &flags);
+
+    return ruby_libvirt_set_typed_parameters(c, hash, NUM2UINT(flags), NULL,
+                                             memory_allowed,
+                                             ARRAY_SIZE(memory_allowed),
+                                             node_memory_set);
+}
+#endif
+
+#if HAVE_VIRNODEGETCPUMAP
+struct cpu_map_field_to_value {
+    VALUE result;
+    int cpu;
+    int used;
+};
+
+static VALUE cpu_map_field_to_value(VALUE input)
+{
+    struct cpu_map_field_to_value *ftv = (struct cpu_map_field_to_value *)input;
+    char cpuname[10];
+
+    snprintf(cpuname, sizeof(cpuname), "%d", ftv->cpu);
+    rb_hash_aset(ftv->result, rb_str_new2(cpuname), ftv->used ? Qtrue : Qfalse);
+
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   conn.node_cpu_map -> Hash
+ *
+ * Call virNodeGetCPUMap[http://www.libvirt.org/html/libvirt-libvirt.html#virNodeGetCPUMap]
+ * to get a map of online host CPUs.
+ */
+static VALUE libvirt_connect_node_cpu_map(int argc, VALUE *argv, VALUE c)
+{
+    VALUE flags, result;
+    unsigned char *map;
+    unsigned int online;
+    int ret, i, exception = 0;
+    struct cpu_map_field_to_value ftv;
+
+    rb_scan_args(argc, argv, "01", &flags);
+
+    ret = virNodeGetCPUMap(ruby_libvirt_connect_get(c), &map, &online,
+                           ruby_libvirt_value_to_uint(flags));
+    ruby_libvirt_raise_error_if(ret < 0, e_RetrieveError, "virNodeGetCPUMap",
+                                ruby_libvirt_connect_get(c));
+
+    result = rb_hash_new();
+
+    for (i = 0; i < ret; i++) {
+        ftv.result = result;
+        ftv.cpu = i;
+        ftv.used = VIR_CPU_USED(map, i);
+        rb_protect(cpu_map_field_to_value, (VALUE)&ftv, &exception);
+        if (exception) {
+            free(map);
+            rb_jump_tag(exception);
+        }
+    }
+
+    free(map);
+
+    return result;
+}
+#endif
+
+#if HAVE_VIRCONNECTSETKEEPALIVE
+/*
+ * call-seq:
+ *   conn.set_keepalive(interval, count) -> fixnum
+ *
+ * Call virConnectSetKeepAlive[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectSetKeepAlive]
+ * to start sending keepalive messages.  Deprecated; use conn.keepalive=
+ * instead.
+ */
+static VALUE libvirt_connect_set_keepalive(VALUE c, VALUE interval, VALUE count)
+{
+    ruby_libvirt_generate_call_int(virConnectSetKeepAlive,
+                                   ruby_libvirt_connect_get(c),
+                                   ruby_libvirt_connect_get(c),
+                                   NUM2INT(interval), NUM2UINT(count));
+}
+
+/*
+ * call-seq:
+ *   conn.keepalive = interval,count
+ *
+ * Call virConnectSetKeepAlive[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectSetKeepAlive]
+ * to start sending keepalive messages.
+ */
+static VALUE libvirt_connect_keepalive_equal(VALUE c, VALUE in)
+{
+    VALUE interval, count;
+
+    Check_Type(in, T_ARRAY);
+
+    if (RARRAY_LEN(in) != 2) {
+        rb_raise(rb_eArgError, "wrong number of arguments (%ld for 2)",
+                 RARRAY_LEN(in));
+    }
+
+    interval = rb_ary_entry(in, 0);
+    count = rb_ary_entry(in, 1);
+
+    ruby_libvirt_generate_call_int(virConnectSetKeepAlive,
+                                   ruby_libvirt_connect_get(c),
+                                   ruby_libvirt_connect_get(c),
+                                   NUM2INT(interval), NUM2UINT(count));
+}
+#endif
+
+#if HAVE_VIRCONNECTLISTALLDOMAINS
+/*
+ * call-seq:
+ *   conn.list_all_domains(flags=0) -> array
+ *
+ * Call virConnectListAllDomains[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListAllDomains]
+ * to get an array of domain objects for all domains.
+ */
+static VALUE libvirt_connect_list_all_domains(int argc, VALUE *argv, VALUE c)
+{
+    ruby_libvirt_generate_call_list_all(virDomainPtr, argc, argv,
+                                        virConnectListAllDomains,
+                                        ruby_libvirt_connect_get(c), c,
+                                        ruby_libvirt_domain_new, virDomainFree);
+}
+#endif
+
+#if HAVE_VIRCONNECTLISTALLNETWORKS
+/*
+ * call-seq:
+ *   conn.list_all_networks(flags=0) -> array
+ *
+ * Call virConnectListAllNetworks[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListAllNetworks]
+ * to get an array of network objects for all networks.
+ */
+static VALUE libvirt_connect_list_all_networks(int argc, VALUE *argv, VALUE c)
+{
+    ruby_libvirt_generate_call_list_all(virNetworkPtr, argc, argv,
+                                        virConnectListAllNetworks,
+                                        ruby_libvirt_connect_get(c), c,
+                                        ruby_libvirt_network_new,
+                                        virNetworkFree);
+}
+#endif
+
+#if HAVE_VIRCONNECTLISTALLINTERFACES
+/*
+ * call-seq:
+ *   conn.list_all_interfaces(flags=0) -> array
+ *
+ * Call virConnectListAllInterfaces[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListAllInterfaces]
+ * to get an array of interface objects for all interfaces.
+ */
+static VALUE libvirt_connect_list_all_interfaces(int argc, VALUE *argv, VALUE c)
+{
+    ruby_libvirt_generate_call_list_all(virInterfacePtr, argc, argv,
+                                        virConnectListAllInterfaces,
+                                        ruby_libvirt_connect_get(c), c,
+                                        ruby_libvirt_interface_new,
+                                        virInterfaceFree);
+}
+#endif
+
+#if HAVE_VIRCONNECTLISTALLSECRETS
+/*
+ * call-seq:
+ *   conn.list_all_secrets(flags=0) -> array
+ *
+ * Call virConnectListAllSecrets[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListAllSecrets]
+ * to get an array of secret objects for all secrets.
+ */
+static VALUE libvirt_connect_list_all_secrets(int argc, VALUE *argv, VALUE c)
+{
+    ruby_libvirt_generate_call_list_all(virSecretPtr, argc, argv,
+                                        virConnectListAllSecrets,
+                                        ruby_libvirt_connect_get(c), c,
+                                        ruby_libvirt_secret_new, virSecretFree);
+}
+#endif
+
+#if HAVE_VIRCONNECTLISTALLNODEDEVICES
+/*
+ * call-seq:
+ *   conn.list_all_nodedevices(flags=0) -> array
+ *
+ * Call virConnectListAllNodeDevices[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListAllNodeDevices]
+ * to get an array of nodedevice objects for all nodedevices.
+ */
+static VALUE libvirt_connect_list_all_nodedevices(int argc, VALUE *argv,
+                                                  VALUE c)
+{
+    ruby_libvirt_generate_call_list_all(virNodeDevicePtr, argc, argv,
+                                        virConnectListAllNodeDevices,
+                                        ruby_libvirt_connect_get(c), c,
+                                        ruby_libvirt_nodedevice_new,
+                                        virNodeDeviceFree);
+}
+#endif
+
+#if HAVE_VIRCONNECTLISTALLSTORAGEPOOLS
+/*
+ * call-seq:
+ *   conn.list_all_storage_pools(flags=0) -> array
+ *
+ * Call virConnectListAllStoragePools[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListAllStoragePools]
+ * to get an array of storage pool objects for all storage pools.
+ */
+static VALUE libvirt_connect_list_all_storage_pools(int argc, VALUE *argv,
+                                                    VALUE c)
+{
+    ruby_libvirt_generate_call_list_all(virStoragePoolPtr, argc, argv,
+                                        virConnectListAllStoragePools,
+                                        ruby_libvirt_connect_get(c), c,
+                                        pool_new, virStoragePoolFree);
+}
+#endif
+
+#if HAVE_VIRCONNECTLISTALLNWFILTERS
+/*
+ * call-seq:
+ *   conn.list_all_nwfilters(flags=0) -> array
+ *
+ * Call virConnectListAllNWFilters[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectListAllNWFilters]
+ * to get an array of nwfilters for all nwfilter objects.
+ */
+static VALUE libvirt_connect_list_all_nwfilters(int argc, VALUE *argv, VALUE c)
+{
+    ruby_libvirt_generate_call_list_all(virNWFilterPtr, argc, argv,
+                                        virConnectListAllNWFilters,
+                                        ruby_libvirt_connect_get(c), c,
+                                        ruby_libvirt_nwfilter_new,
+                                        virNWFilterFree);
+}
+#endif
+
+#if HAVE_VIRCONNECTISALIVE
+/*
+ * call-seq:
+ *   conn.alive? -> [True|False]
+ *
+ * Call virConnectIsAlive[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectIsAlive]
+ * to determine if the connection is alive.
+ */
+static VALUE libvirt_connect_alive_p(VALUE c)
+{
+    ruby_libvirt_generate_call_truefalse(virConnectIsAlive,
+                                         ruby_libvirt_connect_get(c),
+                                         ruby_libvirt_connect_get(c));
+}
+#endif
+
+#if HAVE_VIRDOMAINCREATEXMLWITHFILES
+/*
+ * call-seq:
+ *   conn.create_domain_xml_with_files(xml, fds=nil, flags=0) -> Libvirt::Domain
+ *
+ * Call virDomainCreateXMLWithFiles[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainCreateXMLWithFiles]
+ * to launch a new guest domain with a set of open file descriptors.
+ */
+static VALUE libvirt_connect_create_domain_xml_with_files(int argc, VALUE *argv,
+                                                          VALUE c)
+{
+    VALUE xml, fds, flags;
+    int *files;
+    unsigned int numfiles, i;
+    virDomainPtr dom;
+
+    rb_scan_args(argc, argv, "12", &xml, &fds, &flags);
+
+    Check_Type(xml, T_STRING);
+
+    if (TYPE(fds) == T_NIL) {
+        files = NULL;
+        numfiles = 0;
+    }
+    else if (TYPE(fds) == T_ARRAY) {
+        numfiles = RARRAY_LEN(fds);
+        files = alloca(numfiles * sizeof(int));
+        for (i = 0; i < numfiles; i++) {
+            files[i] = NUM2INT(rb_ary_entry(fds, i));
+        }
+    }
+    else {
+        rb_raise(rb_eTypeError, "wrong argument type (expected Array)");
+    }
+
+    dom = virDomainCreateXMLWithFiles(ruby_libvirt_connect_get(c),
+                                      ruby_libvirt_get_cstring_or_null(xml),
+                                      numfiles, files,
+                                      ruby_libvirt_value_to_uint(flags));
+    ruby_libvirt_raise_error_if(dom == NULL, e_Error,
+                                "virDomainCreateXMLWithFiles",
+                                ruby_libvirt_connect_get(c));
+
+    return ruby_libvirt_domain_new(dom, c);
+}
+#endif
+
+#if HAVE_VIRDOMAINQEMUATTACH
+/*
+ * call-seq:
+ *   conn.qemu_attach(pid, flags=0) -> Libvirt::Domain
+ *
+ * Call virDomainQemuAttach[http://www.libvirt.org/html/libvirt-libvirt.html#virDomainQemuAttach]
+ * to attach to the Qemu process pid.
+ */
+static VALUE libvirt_connect_qemu_attach(int argc, VALUE *argv, VALUE c)
+{
+    VALUE pid, flags;
+    virDomainPtr dom;
+
+    rb_scan_args(argc, argv, "11", &pid, &flags);
+
+    dom = virDomainQemuAttach(ruby_libvirt_connect_get(c), NUM2UINT(pid),
+                              ruby_libvirt_value_to_uint(flags));
+    ruby_libvirt_raise_error_if(dom == NULL, e_Error, "virDomainQemuAttach",
+                                ruby_libvirt_connect_get(c));
+
+    return ruby_libvirt_domain_new(dom, c);
+}
+#endif
+
+#if HAVE_VIRCONNECTGETCPUMODELNAMES
+struct model_name_args {
+    VALUE result;
+    int i;
+    char *value;
+};
+
+static VALUE model_name_wrap(VALUE arg)
+{
+    struct model_name_args *e = (struct model_name_args *)arg;
+    VALUE elem;
+
+    elem = rb_str_new2(e->value);
+
+    rb_ary_store(e->result, e->i, elem);
+
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   conn.cpu_model_names(arch, flags=0) -> Array
+ *
+ * Call virConnectGetCPUModelNames[http://www.libvirt.org/html/libvirt-libvirt.html#virConnectGetCPUModelNames]
+ * to get an array of CPU model names.
+ */
+static VALUE libvirt_connect_cpu_model_names(int argc, VALUE *argv, VALUE c)
+{
+    VALUE arch, flags, result;
+    char **models;
+    int i = 0, j, elems = 0;
+    struct model_name_args args;
+    int exception;
+
+    rb_scan_args(argc, argv, "11", &arch, &flags);
+
+    elems = virConnectGetCPUModelNames(ruby_libvirt_connect_get(c),
+                                       StringValueCStr(arch), &models,
+                                       ruby_libvirt_value_to_uint(flags));
+    ruby_libvirt_raise_error_if(elems < 0, e_RetrieveError,
+                                "virConnectGetCPUModelNames",
+                                ruby_libvirt_connect_get(c));
+
+    result = rb_protect(ruby_libvirt_ary_new2_wrap, (VALUE)&elems, &exception);
+    if (exception) {
+        goto error;
+    }
+
+    for (i = 0; i < elems; i++) {
+        args.result = result;
+        args.i = i;
+        args.value = models[i];
+
+        rb_protect(model_name_wrap, (VALUE)&args, &exception);
+        if (exception) {
+            goto error;
+        }
+        free(models[i]);
+    }
+    free(models);
+
+    return result;
+
+error:
+    for (j = i; j < elems; j++) {
+        free(models[j]);
+    }
+    free(models);
+
+    rb_jump_tag(exception);
+    return Qnil;
+}
+#endif
+
+/*
+ * Class Libvirt::Connect
+ */
+void ruby_libvirt_connect_init(void)
+{
+    c_connect = rb_define_class_under(m_libvirt, "Connect", rb_cObject);
+
+    /*
+     * Class Libvirt::Connect::Nodeinfo
+     */
+    c_node_info = rb_define_class_under(c_connect, "Nodeinfo", rb_cObject);
+    rb_define_attr(c_node_info, "model", 1, 0);
+    rb_define_attr(c_node_info, "memory", 1, 0);
+    rb_define_attr(c_node_info, "cpus", 1, 0);
+    rb_define_attr(c_node_info, "mhz", 1, 0);
+    rb_define_attr(c_node_info, "nodes", 1, 0);
+    rb_define_attr(c_node_info, "sockets", 1, 0);
+    rb_define_attr(c_node_info, "cores", 1, 0);
+    rb_define_attr(c_node_info, "threads", 1, 0);
+
+    /*
+     * Class Libvirt::Connect::NodeSecurityModel
+     */
+    c_node_security_model = rb_define_class_under(c_connect,
+                                                  "NodeSecurityModel",
+                                                  rb_cObject);
+    rb_define_attr(c_node_security_model, "model", 1, 0);
+    rb_define_attr(c_node_security_model, "doi", 1, 0);
+
+    rb_define_method(c_connect, "close", libvirt_connect_close, 0);
+    rb_define_method(c_connect, "closed?", libvirt_connect_closed_p, 0);
+    rb_define_method(c_connect, "type", libvirt_connect_type, 0);
+    rb_define_method(c_connect, "version", libvirt_connect_version, 0);
+#if HAVE_VIRCONNECTGETLIBVERSION
+    rb_define_method(c_connect, "libversion", libvirt_connect_libversion, 0);
+#endif
+    rb_define_method(c_connect, "hostname", libvirt_connect_hostname, 0);
+    rb_define_method(c_connect, "uri", libvirt_connect_uri, 0);
+    rb_define_method(c_connect, "max_vcpus", libvirt_connect_max_vcpus, -1);
+    rb_define_method(c_connect, "node_info", libvirt_connect_node_info, 0);
+    rb_define_alias(c_connect, "node_get_info", "node_info");
+    rb_define_method(c_connect, "node_free_memory",
+                     libvirt_connect_node_free_memory, 0);
+    rb_define_method(c_connect, "node_cells_free_memory",
+                     libvirt_connect_node_cells_free_memory, -1);
+#if HAVE_VIRNODEGETSECURITYMODEL
+    rb_define_method(c_connect, "node_security_model",
+                     libvirt_connect_node_security_model, 0);
+    rb_define_alias(c_connect, "node_get_security_model",
+                    "node_security_model");
+#endif
+#if HAVE_VIRCONNECTISENCRYPTED
+    rb_define_method(c_connect, "encrypted?", libvirt_connect_encrypted_p, 0);
+#endif
+#if HAVE_VIRCONNECTISSECURE
+    rb_define_method(c_connect, "secure?", libvirt_connect_secure_p, 0);
+#endif
+    rb_define_method(c_connect, "capabilities", libvirt_connect_capabilities,
+                     0);
 
 #if HAVE_VIRCONNECTCOMPARECPU
     rb_define_const(c_connect, "CPU_COMPARE_ERROR",
@@ -1964,11 +2747,16 @@ void init_connect()
     rb_define_const(c_connect, "CPU_COMPARE_SUPERSET",
                     INT2NUM(VIR_CPU_COMPARE_SUPERSET));
 
-    rb_define_method(c_connect, "compare_cpu", libvirt_conn_compare_cpu, -1);
+    rb_define_method(c_connect, "compare_cpu", libvirt_connect_compare_cpu, -1);
 #endif
 
 #if HAVE_VIRCONNECTBASELINECPU
-    rb_define_method(c_connect, "baseline_cpu", libvirt_conn_baseline_cpu, -1);
+    rb_define_method(c_connect, "baseline_cpu", libvirt_connect_baseline_cpu,
+                     -1);
+#endif
+#if HAVE_CONST_VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES
+    rb_define_const(c_connect, "BASELINE_CPU_EXPAND_FEATURES",
+                    INT2NUM(VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES));
 #endif
 
     /* In the libvirt development history, the events were
@@ -2101,165 +2889,430 @@ void init_connect()
     rb_define_const(c_connect, "DOMAIN_EVENT_ID_CONTROL_ERROR",
                     INT2NUM(VIR_DOMAIN_EVENT_ID_CONTROL_ERROR));
 #endif
+#if HAVE_CONST_VIR_DOMAIN_EVENT_SHUTDOWN
+    rb_define_const(c_connect, "DOMAIN_EVENT_SHUTDOWN",
+                    INT2NUM(VIR_DOMAIN_EVENT_SHUTDOWN));
+#endif
+#if HAVE_CONST_VIR_DOMAIN_EVENT_PMSUSPENDED
+    rb_define_const(c_connect, "DOMAIN_EVENT_PMSUSPENDED",
+                    INT2NUM(VIR_DOMAIN_EVENT_PMSUSPENDED));
+#endif
+#if HAVE_CONST_VIR_DOMAIN_EVENT_CRASHED
+    rb_define_const(c_connect, "DOMAIN_EVENT_CRASHED",
+                    INT2NUM(VIR_DOMAIN_EVENT_CRASHED));
+#endif
+#if HAVE_CONST_VIR_DOMAIN_EVENT_STARTED_WAKEUP
+    rb_define_const(c_connect, "DOMAIN_EVENT_STARTED_WAKEUP",
+                    INT2NUM(VIR_DOMAIN_EVENT_STARTED_WAKEUP));
+#endif
+#if HAVE_CONST_VIR_DOMAIN_EVENT_SUSPENDED_RESTORED
+    rb_define_const(c_connect, "DOMAIN_EVENT_SUSPENDED_RESTORED",
+                    INT2NUM(VIR_DOMAIN_EVENT_SUSPENDED_RESTORED));
+#endif
+#if HAVE_CONST_VIR_DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT
+    rb_define_const(c_connect, "DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT",
+                    INT2NUM(VIR_DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT));
+#endif
+#if HAVE_CONST_VIR_DOMAIN_EVENT_SUSPENDED_API_ERROR
+    rb_define_const(c_connect, "DOMAIN_EVENT_SUSPENDED_API_ERROR",
+                    INT2NUM(VIR_DOMAIN_EVENT_SUSPENDED_API_ERROR));
+#endif
+#if HAVE_CONST_VIR_DOMAIN_EVENT_RESUMED_FROM_SNAPSHOT
+    rb_define_const(c_connect, "DOMAIN_EVENT_RESUMED_FROM_SNAPSHOT",
+                    INT2NUM(VIR_DOMAIN_EVENT_RESUMED_FROM_SNAPSHOT));
+#endif
+#if HAVE_CONST_VIR_DOMAIN_EVENT_SHUTDOWN_FINISHED
+    rb_define_const(c_connect, "DOMAIN_EVENT_SHUTDOWN_FINISHED",
+                    INT2NUM(VIR_DOMAIN_EVENT_SHUTDOWN_FINISHED));
+#endif
+#if HAVE_CONST_VIR_DOMAIN_EVENT_PMSUSPENDED_MEMORY
+    rb_define_const(c_connect, "DOMAIN_EVENT_PMSUSPENDED_MEMORY",
+                    INT2NUM(VIR_DOMAIN_EVENT_PMSUSPENDED_MEMORY));
+#endif
+#if HAVE_CONST_VIR_DOMAIN_EVENT_PMSUSPENDED_DISK
+    rb_define_const(c_connect, "DOMAIN_EVENT_PMSUSPENDED_DISK",
+                    INT2NUM(VIR_DOMAIN_EVENT_PMSUSPENDED_DISK));
+#endif
+#if HAVE_CONST_VIR_DOMAIN_EVENT_CRASHED_PANICKED
+    rb_define_const(c_connect, "DOMAIN_EVENT_CRASHED_PANICKED",
+                    INT2NUM(VIR_DOMAIN_EVENT_CRASHED_PANICKED));
+#endif
+#if HAVE_CONST_VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_UNIX
+    rb_define_const(c_connect, "DOMAIN_EVENT_GRAPHICS_ADDRESS_UNIX",
+                    INT2NUM(VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_UNIX));
+#endif
 
 #if HAVE_VIRCONNECTDOMAINEVENTREGISTER
     rb_define_method(c_connect, "domain_event_register",
-                     libvirt_conn_domain_event_register, -1);
+                     libvirt_connect_domain_event_register, -1);
     rb_define_method(c_connect, "domain_event_deregister",
-                     libvirt_conn_domain_event_deregister, 0);
+                     libvirt_connect_domain_event_deregister, 0);
 #endif
 
 #if HAVE_VIRCONNECTDOMAINEVENTREGISTERANY
     rb_define_method(c_connect, "domain_event_register_any",
-                     libvirt_conn_domain_event_register_any, -1);
+                     libvirt_connect_domain_event_register_any, -1);
     rb_define_method(c_connect, "domain_event_deregister_any",
-                     libvirt_conn_domain_event_deregister_any, 1);
+                     libvirt_connect_domain_event_deregister_any, 1);
 #endif
 
     /* Domain creation/lookup */
     rb_define_method(c_connect, "num_of_domains",
-                     libvirt_conn_num_of_domains, 0);
-    rb_define_method(c_connect, "list_domains", libvirt_conn_list_domains, 0);
+                     libvirt_connect_num_of_domains, 0);
+    rb_define_method(c_connect, "list_domains", libvirt_connect_list_domains,
+                     0);
     rb_define_method(c_connect, "num_of_defined_domains",
-                     libvirt_conn_num_of_defined_domains, 0);
+                     libvirt_connect_num_of_defined_domains, 0);
     rb_define_method(c_connect, "list_defined_domains",
-                     libvirt_conn_list_defined_domains, 0);
+                     libvirt_connect_list_defined_domains, 0);
     rb_define_method(c_connect, "create_domain_linux",
-                     libvirt_conn_create_linux, -1);
+                     libvirt_connect_create_linux, -1);
 #if HAVE_VIRDOMAINCREATEXML
     rb_define_method(c_connect, "create_domain_xml",
-                     libvirt_conn_create_xml, -1);
+                     libvirt_connect_create_domain_xml, -1);
 #endif
     rb_define_method(c_connect, "lookup_domain_by_name",
-                     libvirt_conn_lookup_domain_by_name, 1);
+                     libvirt_connect_lookup_domain_by_name, 1);
     rb_define_method(c_connect, "lookup_domain_by_id",
-                     libvirt_conn_lookup_domain_by_id, 1);
+                     libvirt_connect_lookup_domain_by_id, 1);
     rb_define_method(c_connect, "lookup_domain_by_uuid",
-                     libvirt_conn_lookup_domain_by_uuid, 1);
+                     libvirt_connect_lookup_domain_by_uuid, 1);
     rb_define_method(c_connect, "define_domain_xml",
-                     libvirt_conn_define_domain_xml, 1);
+                     libvirt_connect_define_domain_xml, 1);
 
 #if HAVE_VIRCONNECTDOMAINXMLFROMNATIVE
     rb_define_method(c_connect, "domain_xml_from_native",
-                     libvirt_conn_domain_xml_from_native, -1);
+                     libvirt_connect_domain_xml_from_native, -1);
 #endif
 #if HAVE_VIRCONNECTDOMAINXMLTONATIVE
     rb_define_method(c_connect, "domain_xml_to_native",
-                     libvirt_conn_domain_xml_to_native, -1);
+                     libvirt_connect_domain_xml_to_native, -1);
 #endif
 
 #if HAVE_TYPE_VIRINTERFACEPTR
     /* Interface lookup/creation methods */
     rb_define_method(c_connect, "num_of_interfaces",
-                     libvirt_conn_num_of_interfaces, 0);
+                     libvirt_connect_num_of_interfaces, 0);
     rb_define_method(c_connect, "list_interfaces",
-                     libvirt_conn_list_interfaces, 0);
+                     libvirt_connect_list_interfaces, 0);
     rb_define_method(c_connect, "num_of_defined_interfaces",
-                     libvirt_conn_num_of_defined_interfaces, 0);
+                     libvirt_connect_num_of_defined_interfaces, 0);
     rb_define_method(c_connect, "list_defined_interfaces",
-                     libvirt_conn_list_defined_interfaces, 0);
+                     libvirt_connect_list_defined_interfaces, 0);
     rb_define_method(c_connect, "lookup_interface_by_name",
-                     libvirt_conn_lookup_interface_by_name, 1);
+                     libvirt_connect_lookup_interface_by_name, 1);
     rb_define_method(c_connect, "lookup_interface_by_mac",
-                     libvirt_conn_lookup_interface_by_mac, 1);
+                     libvirt_connect_lookup_interface_by_mac, 1);
     rb_define_method(c_connect, "define_interface_xml",
-                     libvirt_conn_define_interface_xml, -1);
+                     libvirt_connect_define_interface_xml, -1);
 #endif
 
     /* Network lookup/creation methods */
     rb_define_method(c_connect, "num_of_networks",
-                     libvirt_conn_num_of_networks, 0);
-    rb_define_method(c_connect, "list_networks", libvirt_conn_list_networks, 0);
+                     libvirt_connect_num_of_networks, 0);
+    rb_define_method(c_connect, "list_networks", libvirt_connect_list_networks,
+                     0);
     rb_define_method(c_connect, "num_of_defined_networks",
-                     libvirt_conn_num_of_defined_networks, 0);
+                     libvirt_connect_num_of_defined_networks, 0);
     rb_define_method(c_connect, "list_defined_networks",
-                     libvirt_conn_list_defined_networks, 0);
+                     libvirt_connect_list_defined_networks, 0);
     rb_define_method(c_connect, "lookup_network_by_name",
-                     libvirt_conn_lookup_network_by_name, 1);
+                     libvirt_connect_lookup_network_by_name, 1);
     rb_define_method(c_connect, "lookup_network_by_uuid",
-                     libvirt_conn_lookup_network_by_uuid, 1);
+                     libvirt_connect_lookup_network_by_uuid, 1);
     rb_define_method(c_connect, "create_network_xml",
-                     libvirt_conn_create_network_xml, 1);
+                     libvirt_connect_create_network_xml, 1);
     rb_define_method(c_connect, "define_network_xml",
-                     libvirt_conn_define_network_xml, 1);
+                     libvirt_connect_define_network_xml, 1);
 
     /* Node device lookup/creation methods */
 #if HAVE_TYPE_VIRNODEDEVICEPTR
     rb_define_method(c_connect, "num_of_nodedevices",
-                     libvirt_conn_num_of_nodedevices, -1);
+                     libvirt_connect_num_of_nodedevices, -1);
     rb_define_method(c_connect, "list_nodedevices",
-                     libvirt_conn_list_nodedevices, -1);
+                     libvirt_connect_list_nodedevices, -1);
     rb_define_method(c_connect, "lookup_nodedevice_by_name",
-                     libvirt_conn_lookup_nodedevice_by_name, 1);
+                     libvirt_connect_lookup_nodedevice_by_name, 1);
 #if HAVE_VIRNODEDEVICECREATEXML
     rb_define_method(c_connect, "create_nodedevice_xml",
-                     libvirt_conn_create_nodedevice_xml, -1);
+                     libvirt_connect_create_nodedevice_xml, -1);
 #endif
 #endif
 
 #if HAVE_TYPE_VIRNWFILTERPTR
     /* NWFilter lookup/creation methods */
     rb_define_method(c_connect, "num_of_nwfilters",
-                     libvirt_conn_num_of_nwfilters, 0);
+                     libvirt_connect_num_of_nwfilters, 0);
     rb_define_method(c_connect, "list_nwfilters",
-                     libvirt_conn_list_nwfilters, 0);
+                     libvirt_connect_list_nwfilters, 0);
     rb_define_method(c_connect, "lookup_nwfilter_by_name",
-                     libvirt_conn_lookup_nwfilter_by_name, 1);
+                     libvirt_connect_lookup_nwfilter_by_name, 1);
     rb_define_method(c_connect, "lookup_nwfilter_by_uuid",
-                     libvirt_conn_lookup_nwfilter_by_uuid, 1);
+                     libvirt_connect_lookup_nwfilter_by_uuid, 1);
     rb_define_method(c_connect, "define_nwfilter_xml",
-                     libvirt_conn_define_nwfilter_xml, 1);
+                     libvirt_connect_define_nwfilter_xml, 1);
 #endif
 
 #if HAVE_TYPE_VIRSECRETPTR
     /* Secret lookup/creation methods */
     rb_define_method(c_connect, "num_of_secrets",
-                     libvirt_conn_num_of_secrets, 0);
+                     libvirt_connect_num_of_secrets, 0);
     rb_define_method(c_connect, "list_secrets",
-                     libvirt_conn_list_secrets, 0);
+                     libvirt_connect_list_secrets, 0);
     rb_define_method(c_connect, "lookup_secret_by_uuid",
-                     libvirt_conn_lookup_secret_by_uuid, 1);
+                     libvirt_connect_lookup_secret_by_uuid, 1);
     rb_define_method(c_connect, "lookup_secret_by_usage",
-                     libvirt_conn_lookup_secret_by_usage, 2);
+                     libvirt_connect_lookup_secret_by_usage, 2);
     rb_define_method(c_connect, "define_secret_xml",
-                     libvirt_conn_define_secret_xml, -1);
+                     libvirt_connect_define_secret_xml, -1);
 #endif
 
 #if HAVE_TYPE_VIRSTORAGEPOOLPTR
     /* StoragePool lookup/creation methods */
     rb_define_method(c_connect, "num_of_storage_pools",
-                     libvirt_conn_num_of_storage_pools, 0);
+                     libvirt_connect_num_of_storage_pools, 0);
     rb_define_method(c_connect, "list_storage_pools",
-                     libvirt_conn_list_storage_pools, 0);
+                     libvirt_connect_list_storage_pools, 0);
     rb_define_method(c_connect, "num_of_defined_storage_pools",
-                     libvirt_conn_num_of_defined_storage_pools, 0);
+                     libvirt_connect_num_of_defined_storage_pools, 0);
     rb_define_method(c_connect, "list_defined_storage_pools",
-                     libvirt_conn_list_defined_storage_pools, 0);
+                     libvirt_connect_list_defined_storage_pools, 0);
     rb_define_method(c_connect, "lookup_storage_pool_by_name",
-                     libvirt_conn_lookup_pool_by_name, 1);
+                     libvirt_connect_lookup_pool_by_name, 1);
     rb_define_method(c_connect, "lookup_storage_pool_by_uuid",
-                     libvirt_conn_lookup_pool_by_uuid, 1);
+                     libvirt_connect_lookup_pool_by_uuid, 1);
     rb_define_method(c_connect, "create_storage_pool_xml",
-                     libvirt_conn_create_pool_xml, -1);
+                     libvirt_connect_create_pool_xml, -1);
     rb_define_method(c_connect, "define_storage_pool_xml",
-                     libvirt_conn_define_pool_xml, -1);
+                     libvirt_connect_define_pool_xml, -1);
     rb_define_method(c_connect, "discover_storage_pool_sources",
-                     libvirt_conn_find_storage_pool_sources, -1);
+                     libvirt_connect_find_storage_pool_sources, -1);
 #endif
 
 #if HAVE_VIRCONNECTGETSYSINFO
-    rb_define_method(c_connect, "sys_info", libvirt_conn_get_sys_info, -1);
+    rb_define_method(c_connect, "sys_info", libvirt_connect_sys_info, -1);
 #endif
 #if HAVE_TYPE_VIRSTREAMPTR
-    rb_define_method(c_connect, "stream", libvirt_conn_stream, -1);
+    rb_define_method(c_connect, "stream", libvirt_connect_stream, -1);
 #endif
 
 #if HAVE_VIRINTERFACECHANGEBEGIN
     rb_define_method(c_connect, "interface_change_begin",
-                     libvirt_conn_interface_change_begin, -1);
+                     libvirt_connect_interface_change_begin, -1);
     rb_define_method(c_connect, "interface_change_commit",
-                     libvirt_conn_interface_change_commit, -1);
+                     libvirt_connect_interface_change_commit, -1);
     rb_define_method(c_connect, "interface_change_rollback",
-                     libvirt_conn_interface_change_rollback, -1);
+                     libvirt_connect_interface_change_rollback, -1);
+#endif
+
+#if HAVE_VIRNODEGETCPUSTATS
+    rb_define_method(c_connect, "node_cpu_stats",
+                     libvirt_connect_node_cpu_stats, -1);
+#endif
+#if HAVE_CONST_VIR_NODE_CPU_STATS_ALL_CPUS
+    rb_define_const(c_connect, "NODE_CPU_STATS_ALL_CPUS",
+                    INT2NUM(VIR_NODE_CPU_STATS_ALL_CPUS));
+#endif
+#if HAVE_VIRNODEGETMEMORYSTATS
+    rb_define_method(c_connect, "node_memory_stats",
+                     libvirt_connect_node_memory_stats, -1);
+#endif
+#if HAVE_CONST_VIR_NODE_MEMORY_STATS_ALL_CELLS
+    rb_define_const(c_connect, "NODE_MEMORY_STATS_ALL_CELLS",
+                    INT2NUM(VIR_NODE_MEMORY_STATS_ALL_CELLS));
+#endif
+
+#if HAVE_VIRDOMAINSAVEIMAGEGETXMLDESC
+    rb_define_method(c_connect, "save_image_xml_desc",
+                     libvirt_connect_save_image_xml_desc, -1);
+    rb_define_method(c_connect, "define_save_image_xml",
+                     libvirt_connect_define_save_image_xml, -1);
+#endif
+
+#if HAVE_VIRNODESUSPENDFORDURATION
+    rb_define_const(c_connect, "NODE_SUSPEND_TARGET_MEM",
+                    INT2NUM(VIR_NODE_SUSPEND_TARGET_MEM));
+    rb_define_const(c_connect, "NODE_SUSPEND_TARGET_DISK",
+                    INT2NUM(VIR_NODE_SUSPEND_TARGET_DISK));
+    rb_define_const(c_connect, "NODE_SUSPEND_TARGET_HYBRID",
+                    INT2NUM(VIR_NODE_SUSPEND_TARGET_HYBRID));
+
+    rb_define_method(c_connect, "node_suspend_for_duration",
+                     libvirt_connect_node_suspend_for_duration, -1);
+#endif
+
+#if HAVE_VIRNODEGETMEMORYPARAMETERS
+    rb_define_method(c_connect, "node_memory_parameters",
+                     libvirt_connect_node_memory_parameters, -1);
+    rb_define_method(c_connect, "node_memory_parameters=",
+                     libvirt_connect_node_memory_parameters_equal, 1);
+#endif
+
+#if HAVE_VIRNODEGETCPUMAP
+    rb_define_method(c_connect, "node_cpu_map",
+                     libvirt_connect_node_cpu_map, -1);
+    rb_define_alias(c_connect, "node_get_cpu_map", "node_cpu_map");
+#endif
+
+#if HAVE_VIRCONNECTSETKEEPALIVE
+    rb_define_method(c_connect, "set_keepalive",
+                     libvirt_connect_set_keepalive, 2);
+    rb_define_method(c_connect, "keepalive=", libvirt_connect_keepalive_equal,
+                     1);
+#endif
+
+#if HAVE_VIRCONNECTLISTALLDOMAINS
+    rb_define_const(c_connect, "LIST_DOMAINS_ACTIVE",
+                    INT2NUM(VIR_CONNECT_LIST_DOMAINS_ACTIVE));
+    rb_define_const(c_connect, "LIST_DOMAINS_INACTIVE",
+                    INT2NUM(VIR_CONNECT_LIST_DOMAINS_INACTIVE));
+    rb_define_const(c_connect, "LIST_DOMAINS_PERSISTENT",
+                    INT2NUM(VIR_CONNECT_LIST_DOMAINS_PERSISTENT));
+    rb_define_const(c_connect, "LIST_DOMAINS_TRANSIENT",
+                    INT2NUM(VIR_CONNECT_LIST_DOMAINS_TRANSIENT));
+    rb_define_const(c_connect, "LIST_DOMAINS_RUNNING",
+                    INT2NUM(VIR_CONNECT_LIST_DOMAINS_RUNNING));
+    rb_define_const(c_connect, "LIST_DOMAINS_PAUSED",
+                    INT2NUM(VIR_CONNECT_LIST_DOMAINS_PAUSED));
+    rb_define_const(c_connect, "LIST_DOMAINS_SHUTOFF",
+                    INT2NUM(VIR_CONNECT_LIST_DOMAINS_SHUTOFF));
+    rb_define_const(c_connect, "LIST_DOMAINS_OTHER",
+                    INT2NUM(VIR_CONNECT_LIST_DOMAINS_OTHER));
+    rb_define_const(c_connect, "LIST_DOMAINS_MANAGEDSAVE",
+                    INT2NUM(VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE));
+    rb_define_const(c_connect, "LIST_DOMAINS_NO_MANAGEDSAVE",
+                    INT2NUM(VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE));
+    rb_define_const(c_connect, "LIST_DOMAINS_AUTOSTART",
+                    INT2NUM(VIR_CONNECT_LIST_DOMAINS_AUTOSTART));
+    rb_define_const(c_connect, "LIST_DOMAINS_NO_AUTOSTART",
+                    INT2NUM(VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART));
+    rb_define_const(c_connect, "LIST_DOMAINS_HAS_SNAPSHOT",
+                    INT2NUM(VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT));
+    rb_define_const(c_connect, "LIST_DOMAINS_NO_SNAPSHOT",
+                    INT2NUM(VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT));
+    rb_define_method(c_connect, "list_all_domains",
+                     libvirt_connect_list_all_domains, -1);
+#endif
+#if HAVE_VIRCONNECTLISTALLNETWORKS
+    rb_define_const(c_connect, "LIST_NETWORKS_ACTIVE",
+                    INT2NUM(VIR_CONNECT_LIST_NETWORKS_ACTIVE));
+    rb_define_const(c_connect, "LIST_NETWORKS_INACTIVE",
+                    INT2NUM(VIR_CONNECT_LIST_NETWORKS_INACTIVE));
+    rb_define_const(c_connect, "LIST_NETWORKS_PERSISTENT",
+                    INT2NUM(VIR_CONNECT_LIST_NETWORKS_PERSISTENT));
+    rb_define_const(c_connect, "LIST_NETWORKS_TRANSIENT",
+                    INT2NUM(VIR_CONNECT_LIST_NETWORKS_TRANSIENT));
+    rb_define_const(c_connect, "LIST_NETWORKS_AUTOSTART",
+                    INT2NUM(VIR_CONNECT_LIST_NETWORKS_AUTOSTART));
+    rb_define_const(c_connect, "LIST_NETWORKS_NO_AUTOSTART",
+                    INT2NUM(VIR_CONNECT_LIST_NETWORKS_NO_AUTOSTART));
+    rb_define_method(c_connect, "list_all_networks",
+                     libvirt_connect_list_all_networks, -1);
+#endif
+#if HAVE_VIRCONNECTLISTALLINTERFACES
+    rb_define_const(c_connect, "LIST_INTERFACES_INACTIVE",
+                    INT2NUM(VIR_CONNECT_LIST_INTERFACES_INACTIVE));
+    rb_define_const(c_connect, "LIST_INTERFACES_ACTIVE",
+                    INT2NUM(VIR_CONNECT_LIST_INTERFACES_ACTIVE));
+    rb_define_method(c_connect, "list_all_interfaces",
+                     libvirt_connect_list_all_interfaces, -1);
+#endif
+#if HAVE_VIRCONNECTLISTALLSECRETS
+    rb_define_const(c_connect, "LIST_SECRETS_EPHEMERAL",
+                    INT2NUM(VIR_CONNECT_LIST_SECRETS_EPHEMERAL));
+    rb_define_const(c_connect, "LIST_SECRETS_NO_EPHEMERAL",
+                    INT2NUM(VIR_CONNECT_LIST_SECRETS_NO_EPHEMERAL));
+    rb_define_const(c_connect, "LIST_SECRETS_PRIVATE",
+                    INT2NUM(VIR_CONNECT_LIST_SECRETS_PRIVATE));
+    rb_define_const(c_connect, "LIST_SECRETS_NO_PRIVATE",
+                    INT2NUM(VIR_CONNECT_LIST_SECRETS_NO_PRIVATE));
+    rb_define_method(c_connect, "list_all_secrets",
+                     libvirt_connect_list_all_secrets, -1);
+#endif
+#if HAVE_VIRCONNECTLISTALLNODEDEVICES
+    rb_define_const(c_connect, "LIST_NODE_DEVICES_CAP_SYSTEM",
+                    INT2NUM(VIR_CONNECT_LIST_NODE_DEVICES_CAP_SYSTEM));
+    rb_define_const(c_connect, "LIST_NODE_DEVICES_CAP_PCI_DEV",
+                    INT2NUM(VIR_CONNECT_LIST_NODE_DEVICES_CAP_PCI_DEV));
+    rb_define_const(c_connect, "LIST_NODE_DEVICES_CAP_USB_DEV",
+                    INT2NUM(VIR_CONNECT_LIST_NODE_DEVICES_CAP_USB_DEV));
+    rb_define_const(c_connect, "LIST_NODE_DEVICES_CAP_USB_INTERFACE",
+                    INT2NUM(VIR_CONNECT_LIST_NODE_DEVICES_CAP_USB_INTERFACE));
+    rb_define_const(c_connect, "LIST_NODE_DEVICES_CAP_NET",
+                    INT2NUM(VIR_CONNECT_LIST_NODE_DEVICES_CAP_NET));
+    rb_define_const(c_connect, "LIST_NODE_DEVICES_CAP_SCSI_HOST",
+                    INT2NUM(VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_HOST));
+    rb_define_const(c_connect, "LIST_NODE_DEVICES_CAP_SCSI_TARGET",
+                    INT2NUM(VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_TARGET));
+    rb_define_const(c_connect, "LIST_NODE_DEVICES_CAP_SCSI",
+                    INT2NUM(VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI));
+    rb_define_const(c_connect, "LIST_NODE_DEVICES_CAP_STORAGE",
+                    INT2NUM(VIR_CONNECT_LIST_NODE_DEVICES_CAP_STORAGE));
+#if HAVE_CONST_VIR_CONNECT_LIST_NODE_DEVICES_CAP_FC_HOST
+    rb_define_const(c_connect, "LIST_NODE_DEVICES_CAP_FC_HOST",
+                    INT2NUM(VIR_CONNECT_LIST_NODE_DEVICES_CAP_FC_HOST));
+    rb_define_const(c_connect, "LIST_NODE_DEVICES_CAP_VPORTS",
+                    INT2NUM(VIR_CONNECT_LIST_NODE_DEVICES_CAP_VPORTS));
+#endif
+#if HAVE_CONST_VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_GENERIC
+    rb_define_const(c_connect, "LIST_NODE_DEVICES_CAP_SCSI_GENERIC",
+                    INT2NUM(VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_GENERIC));
+#endif
+    rb_define_method(c_connect, "list_all_nodedevices",
+                     libvirt_connect_list_all_nodedevices, -1);
+#endif
+#if HAVE_VIRCONNECTLISTALLSTORAGEPOOLS
+    rb_define_const(c_connect, "LIST_STORAGE_POOLS_INACTIVE",
+                    INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_INACTIVE));
+    rb_define_const(c_connect, "LIST_STORAGE_POOLS_ACTIVE",
+                    INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_ACTIVE));
+    rb_define_const(c_connect, "LIST_STORAGE_POOLS_PERSISTENT",
+                    INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_PERSISTENT));
+    rb_define_const(c_connect, "LIST_STORAGE_POOLS_TRANSIENT",
+                    INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_TRANSIENT));
+    rb_define_const(c_connect, "LIST_STORAGE_POOLS_AUTOSTART",
+                    INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_AUTOSTART));
+    rb_define_const(c_connect, "LIST_STORAGE_POOLS_NO_AUTOSTART",
+                    INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_NO_AUTOSTART));
+    rb_define_const(c_connect, "LIST_STORAGE_POOLS_DIR",
+                    INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_DIR));
+    rb_define_const(c_connect, "LIST_STORAGE_POOLS_FS",
+                    INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_FS));
+    rb_define_const(c_connect, "LIST_STORAGE_POOLS_NETFS",
+                    INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_NETFS));
+    rb_define_const(c_connect, "LIST_STORAGE_POOLS_LOGICAL",
+                    INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_LOGICAL));
+    rb_define_const(c_connect, "LIST_STORAGE_POOLS_DISK",
+                    INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_DISK));
+    rb_define_const(c_connect, "LIST_STORAGE_POOLS_ISCSI",
+                    INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_ISCSI));
+    rb_define_const(c_connect, "LIST_STORAGE_POOLS_SCSI",
+                    INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_SCSI));
+    rb_define_const(c_connect, "LIST_STORAGE_POOLS_MPATH",
+                    INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_MPATH));
+    rb_define_const(c_connect, "LIST_STORAGE_POOLS_RBD",
+                    INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_RBD));
+    rb_define_const(c_connect, "LIST_STORAGE_POOLS_SHEEPDOG",
+                    INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_SHEEPDOG));
+    rb_define_method(c_connect, "list_all_storage_pools",
+                     libvirt_connect_list_all_storage_pools, -1);
+#endif
+#if HAVE_VIRCONNECTLISTALLNWFILTERS
+    rb_define_method(c_connect, "list_all_nwfilters",
+                     libvirt_connect_list_all_nwfilters, -1);
+#endif
+#if HAVE_VIRCONNECTISALIVE
+    rb_define_method(c_connect, "alive?", libvirt_connect_alive_p, 0);
+#endif
+#if HAVE_VIRDOMAINCREATEXMLWITHFILES
+    rb_define_method(c_connect, "create_domain_xml_with_files",
+                     libvirt_connect_create_domain_xml_with_files, -1);
+#endif
+#if HAVE_VIRDOMAINQEMUATTACH
+    rb_define_method(c_connect, "qemu_attach", libvirt_connect_qemu_attach, -1);
+#endif
+#if HAVE_VIRCONNECTGETCPUMODELNAMES
+    rb_define_method(c_connect, "cpu_model_names",
+                     libvirt_connect_cpu_model_names, -1);
 #endif
 }