ruby-libvirt 0.4.0 → 0.5.0

data/ext/libvirt/nwfilter.h

@@ -1,6 +1,8 @@
 #ifndef NWFILTER_H
 #define NWFILTER_H
 
-void init_nwfilter();
+void ruby_libvirt_nwfilter_init(void);
+
+VALUE ruby_libvirt_nwfilter_new(virNWFilterPtr n, VALUE conn);
 
 #endif

data/ext/libvirt/secret.c

@@ -2,6 +2,7 @@
  * secret.c: virSecret methods
  *
  * Copyright (C) 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
@@ -28,136 +29,173 @@
 #if HAVE_TYPE_VIRSECRETPTR
 static VALUE c_secret;
 
-static void secret_free(void *s) {
-    generic_free(Secret, s);
+static void secret_free(void *s)
+{
+    ruby_libvirt_free_struct(Secret, s);
 }
 
-static virSecretPtr secret_get(VALUE s) {
-    generic_get(Secret, s);
+static virSecretPtr secret_get(VALUE s)
+{
+    ruby_libvirt_get_struct(Secret, s);
 }
 
-VALUE secret_new(virSecretPtr s, VALUE conn) {
-    return generic_new(c_secret, s, conn, secret_free);
+VALUE ruby_libvirt_secret_new(virSecretPtr s, VALUE conn)
+{
+    return ruby_libvirt_new_class(c_secret, s, conn, secret_free);
 }
 
 /*
  * call-seq:
  *   secret.uuid -> string
  *
- * Call +virSecretGetUUIDString+[http://www.libvirt.org/html/libvirt-libvirt.html#virSecretGetUUIDString]
+ * Call virSecretGetUUIDString[http://www.libvirt.org/html/libvirt-libvirt.html#virSecretGetUUIDString]
  * to retrieve the UUID for this secret.
  */
-static VALUE libvirt_secret_uuid(VALUE s) {
-    virSecretPtr secret = secret_get(s);
-    int r;
-    char uuid[VIR_UUID_STRING_BUFLEN];
-
-    r = virSecretGetUUIDString(secret, uuid);
-    _E(r < 0, create_error(e_RetrieveError, "virSecretGetUUIDString", conn(s)));
-
-    return rb_str_new2((char *)uuid);
+static VALUE libvirt_secret_uuid(VALUE s)
+{
+    ruby_libvirt_generate_uuid(virSecretGetUUIDString,
+                               ruby_libvirt_connect_get(s), secret_get(s));
 }
 
 /*
  * call-seq:
  *   secret.usagetype -> fixnum
  *
- * Call +virSecretGetUsageType+[http://www.libvirt.org/html/libvirt-libvirt.html#virSecretGetUsageType]
+ * Call virSecretGetUsageType[http://www.libvirt.org/html/libvirt-libvirt.html#virSecretGetUsageType]
  * to retrieve the usagetype for this secret.
  */
-static VALUE libvirt_secret_usagetype(VALUE s) {
-    gen_call_int(virSecretGetUsageType, conn(s), secret_get(s));
+static VALUE libvirt_secret_usagetype(VALUE s)
+{
+    ruby_libvirt_generate_call_int(virSecretGetUsageType,
+                                   ruby_libvirt_connect_get(s),
+                                   secret_get(s));
 }
 
 /*
  * call-seq:
  *   secret.usageid -> string
  *
- * Call +virSecretGetUsageID+[http://www.libvirt.org/html/libvirt-libvirt.html#virSecretGetUsageID]
+ * Call virSecretGetUsageID[http://www.libvirt.org/html/libvirt-libvirt.html#virSecretGetUsageID]
  * to retrieve the usageid for this secret.
  */
-static VALUE libvirt_secret_usageid(VALUE s) {
-    gen_call_string(virSecretGetUsageID, conn(s), 0, secret_get(s));
+static VALUE libvirt_secret_usageid(VALUE s)
+{
+    ruby_libvirt_generate_call_string(virSecretGetUsageID,
+                                      ruby_libvirt_connect_get(s), 0,
+                                      secret_get(s));
 }
 
 /*
  * call-seq:
  *   secret.xml_desc(flags=0) -> string
  *
- * Call +virSecretGetXMLDesc+[http://www.libvirt.org/html/libvirt-libvirt.html#virSecretGetXMLDesc]
+ * Call virSecretGetXMLDesc[http://www.libvirt.org/html/libvirt-libvirt.html#virSecretGetXMLDesc]
  * to retrieve the XML for this secret.
  */
-static VALUE libvirt_secret_xml_desc(int argc, VALUE *argv, VALUE s) {
+static VALUE libvirt_secret_xml_desc(int argc, VALUE *argv, VALUE s)
+{
     VALUE flags;
 
     rb_scan_args(argc, argv, "01", &flags);
 
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
-
-    gen_call_string(virSecretGetXMLDesc, conn(s), 1, secret_get(s),
-                    NUM2UINT(flags));
+    ruby_libvirt_generate_call_string(virSecretGetXMLDesc,
+                                      ruby_libvirt_connect_get(s), 1,
+                                      secret_get(s),
+                                      ruby_libvirt_value_to_uint(flags));
 }
 
 /*
  * call-seq:
  *   secret.set_value(value, flags=0) -> nil
  *
- * Call +virSecretSetValue+[http://www.libvirt.org/html/libvirt-libvirt.html#virSecretSetValue]
- * to set a new value in this secret.
+ * Call virSecretSetValue[http://www.libvirt.org/html/libvirt-libvirt.html#virSecretSetValue]
+ * to set a new value in this secret.  Deprecated; use secret.value= instead.
  */
-static VALUE libvirt_secret_set_value(int argc, VALUE *argv, VALUE s) {
-    VALUE flags;
-    VALUE value;
+static VALUE libvirt_secret_set_value(int argc, VALUE *argv, VALUE s)
+{
+    VALUE flags, value;
 
     rb_scan_args(argc, argv, "11", &value, &flags);
 
-    if (NIL_P(flags))
+    StringValue(value);
+
+    ruby_libvirt_generate_call_nil(virSecretSetValue,
+                                   ruby_libvirt_connect_get(s),
+                                   secret_get(s),
+                                   (unsigned char *)RSTRING_PTR(value),
+                                   RSTRING_LEN(value),
+                                   ruby_libvirt_value_to_uint(flags));
+}
+
+/*
+ * call-seq:
+ *   secret.value = value,flags=0
+ *
+ * Call virSecretSetValue[http://www.libvirt.org/html/libvirt-libvirt.html#virSecretSetValue]
+ * to set a new value in this secret.
+ */
+static VALUE libvirt_secret_value_equal(VALUE s, VALUE in)
+{
+    VALUE flags, value;
+
+    if (TYPE(in) == T_STRING) {
+        value = in;
         flags = INT2NUM(0);
+    }
+    else if (TYPE(in) == T_ARRAY) {
+        if (RARRAY_LEN(in) != 2) {
+            rb_raise(rb_eArgError, "wrong number of arguments (%ld for 2)",
+                     RARRAY_LEN(in));
+        }
+        value = rb_ary_entry(in, 0);
+        flags = rb_ary_entry(in, 1);
+    }
+    else {
+        rb_raise(rb_eTypeError,
+                 "wrong argument type (expected Number or Array)");
+    }
 
     StringValue(value);
 
-    gen_call_void(virSecretSetValue, conn(s), secret_get(s),
-                  (unsigned char *)RSTRING_PTR(value), RSTRING_LEN(value),
-                  NUM2UINT(flags));
+    ruby_libvirt_generate_call_nil(virSecretSetValue,
+                                   ruby_libvirt_connect_get(s),
+                                   secret_get(s),
+                                   (unsigned char *)RSTRING_PTR(value),
+                                   RSTRING_LEN(value), NUM2UINT(flags));
 }
 
 /*
  * call-seq:
- *   secret.get_value(flags=0) -> string
+ *   secret.value(flags=0) -> string
  *
- * Call +virSecretGetValue+[http://www.libvirt.org/html/libvirt-libvirt.html#virSecretGetValue]
+ * Call virSecretGetValue[http://www.libvirt.org/html/libvirt-libvirt.html#virSecretGetValue]
  * to retrieve the value from this secret.
  */
-static VALUE libvirt_secret_get_value(int argc, VALUE *argv, VALUE s) {
-    virSecretPtr secret = secret_get(s);
-    VALUE flags;
+static VALUE libvirt_secret_value(int argc, VALUE *argv, VALUE s)
+{
+    VALUE flags, ret;
     unsigned char *val;
     size_t value_size;
-    VALUE ret;
     int exception = 0;
-    struct rb_str_new_arg args;
+    struct ruby_libvirt_str_new_arg args;
 
     rb_scan_args(argc, argv, "01", &flags);
 
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
+    val = virSecretGetValue(secret_get(s), &value_size,
+                            ruby_libvirt_value_to_uint(flags));
 
-    val = virSecretGetValue(secret, &value_size, NUM2UINT(flags));
-
-    _E(val == NULL, create_error(e_RetrieveError, "virSecretGetValue",
-                                 conn(s)));
+    ruby_libvirt_raise_error_if(val == NULL, e_RetrieveError,
+                                "virSecretGetValue",
+                                ruby_libvirt_connect_get(s));
 
     args.val = (char *)val;
     args.size = value_size;
-    ret = rb_protect(rb_str_new_wrap, (VALUE)&args, &exception);
+    ret = rb_protect(ruby_libvirt_str_new_wrap, (VALUE)&args, &exception);
+    free(val);
     if (exception) {
-        free(val);
         rb_jump_tag(exception);
     }
 
-    free(val);
-
     return ret;
 }
 
@@ -165,22 +203,26 @@ static VALUE libvirt_secret_get_value(int argc, VALUE *argv, VALUE s) {
  * call-seq:
  *   secret.undefine -> nil
  *
- * Call +virSecretUndefine+[http://www.libvirt.org/html/libvirt-libvirt.html#virSecretUndefine]
+ * Call virSecretUndefine[http://www.libvirt.org/html/libvirt-libvirt.html#virSecretUndefine]
  * to undefine this secret.
  */
-static VALUE libvirt_secret_undefine(VALUE s) {
-    gen_call_void(virSecretUndefine, conn(s), secret_get(s));
+static VALUE libvirt_secret_undefine(VALUE s)
+{
+    ruby_libvirt_generate_call_nil(virSecretUndefine,
+                                   ruby_libvirt_connect_get(s),
+                                   secret_get(s));
 }
 
 /*
  * call-seq:
  *   secret.free -> nil
  *
- * Call +virSecretFree+[http://www.libvirt.org/html/libvirt-libvirt.html#virSecretFree]
+ * Call virSecretFree[http://www.libvirt.org/html/libvirt-libvirt.html#virSecretFree]
  * to free this secret.  After this call the secret object is no longer valid.
  */
-static VALUE libvirt_secret_free(VALUE s) {
-    gen_call_free(Secret, s);
+static VALUE libvirt_secret_free(VALUE s)
+{
+    ruby_libvirt_generate_call_free(Secret, s);
 }
 
 #endif
@@ -188,14 +230,28 @@ static VALUE libvirt_secret_free(VALUE s) {
 /*
  * Class Libvirt::Secret
  */
-void init_secret()
+void ruby_libvirt_secret_init(void)
 {
 #if HAVE_TYPE_VIRSECRETPTR
     c_secret = rb_define_class_under(m_libvirt, "Secret", rb_cObject);
 
+    rb_define_attr(c_secret, "connection", 1, 0);
+
     rb_define_const(c_secret, "USAGE_TYPE_VOLUME",
                     INT2NUM(VIR_SECRET_USAGE_TYPE_VOLUME));
-    rb_define_attr(c_secret, "connection", 1, 0);
+
+#if HAVE_CONST_VIR_SECRET_USAGE_TYPE_CEPH
+    rb_define_const(c_secret, "USAGE_TYPE_CEPH",
+                    INT2NUM(VIR_SECRET_USAGE_TYPE_CEPH));
+#endif
+#if HAVE_CONST_VIR_SECRET_USAGE_TYPE_ISCSI
+    rb_define_const(c_secret, "USAGE_TYPE_ISCSI",
+                    INT2NUM(VIR_SECRET_USAGE_TYPE_ISCSI));
+#endif
+#if HAVE_CONST_VIR_SECRET_USAGE_TYPE_NONE
+    rb_define_const(c_secret, "USAGE_TYPE_NONE",
+                    INT2NUM(VIR_SECRET_USAGE_TYPE_NONE));
+#endif
 
     /* Secret object methods */
     rb_define_method(c_secret, "uuid", libvirt_secret_uuid, 0);
@@ -203,7 +259,9 @@ void init_secret()
     rb_define_method(c_secret, "usageid", libvirt_secret_usageid, 0);
     rb_define_method(c_secret, "xml_desc", libvirt_secret_xml_desc, -1);
     rb_define_method(c_secret, "set_value", libvirt_secret_set_value, -1);
-    rb_define_method(c_secret, "get_value", libvirt_secret_get_value, -1);
+    rb_define_method(c_secret, "value=", libvirt_secret_value_equal, 1);
+    rb_define_method(c_secret, "value", libvirt_secret_value, -1);
+    rb_define_alias(c_secret, "get_value", "value");
     rb_define_method(c_secret, "undefine", libvirt_secret_undefine, 0);
     rb_define_method(c_secret, "free", libvirt_secret_free, 0);
 #endif

data/ext/libvirt/secret.h

@@ -1,6 +1,8 @@
 #ifndef SECRET_H
 #define SECRET_H
 
-void init_secret();
+void ruby_libvirt_secret_init(void);
+
+VALUE ruby_libvirt_secret_new(virSecretPtr s, VALUE conn);
 
 #endif

data/ext/libvirt/storage.c

@@ -2,6 +2,7 @@
  * storage.c: virStoragePool and virStorageVolume 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
@@ -28,10 +29,11 @@
 
 #if HAVE_TYPE_VIRSTORAGEVOLPTR
 /* this has to be here (as opposed to below with the rest of the volume
- * stuff) because libvirt_vol_get_pool() relies on it
+ * stuff) because libvirt_storage_vol_get_pool() relies on it
  */
-static virStorageVolPtr vol_get(VALUE s) {
-    generic_get(StorageVol, s);
+static virStorageVolPtr vol_get(VALUE v)
+{
+    ruby_libvirt_get_struct(StorageVol, v);
 }
 #endif
 
@@ -43,173 +45,189 @@ static VALUE c_storage_pool_info;
  * Class Libvirt::StoragePool
  */
 
-static void pool_free(void *d) {
-    generic_free(StoragePool, d);
+static void pool_free(void *d)
+{
+    ruby_libvirt_free_struct(StoragePool, d);
 }
 
-static virStoragePoolPtr pool_get(VALUE s) {
-    generic_get(StoragePool, s);
+static virStoragePoolPtr pool_get(VALUE p)
+{
+    ruby_libvirt_get_struct(StoragePool, p);
 }
 
-VALUE pool_new(virStoragePoolPtr n, VALUE conn) {
-    return generic_new(c_storage_pool, n, conn, pool_free);
+VALUE pool_new(virStoragePoolPtr p, VALUE conn)
+{
+    return ruby_libvirt_new_class(c_storage_pool, p, conn, pool_free);
 }
 
 /*
  * call-seq:
  *   vol.pool -> Libvirt::StoragePool
  *
- * Call +virStoragePoolLookupByVolume+[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolLookupByVolume]
+ * Call virStoragePoolLookupByVolume[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolLookupByVolume]
  * to retrieve the storage pool for this volume.
  */
-static VALUE libvirt_vol_get_pool(VALUE v) {
+static VALUE libvirt_storage_vol_pool(VALUE v)
+{
     virStoragePoolPtr pool;
 
     pool = virStoragePoolLookupByVolume(vol_get(v));
-    _E(pool == NULL, create_error(e_RetrieveError,
-                                  "virStoragePoolLookupByVolume", conn(v)));
+    ruby_libvirt_raise_error_if(pool == NULL, e_RetrieveError,
+                                "virStoragePoolLookupByVolume",
+                                ruby_libvirt_connect_get(v));
 
-    return pool_new(pool, conn_attr(v));
+    return pool_new(pool, ruby_libvirt_conn_attr(v));
 }
 
 /*
  * call-seq:
  *   pool.build(flags=0) -> nil
  *
- * Call +virStoragePoolBuild+[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolBuild]
+ * Call virStoragePoolBuild[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolBuild]
  * to build this storage pool.
  */
-static VALUE libvirt_pool_build(int argc, VALUE *argv, VALUE p) {
+static VALUE libvirt_storage_pool_build(int argc, VALUE *argv, VALUE p)
+{
     VALUE flags;
 
     rb_scan_args(argc, argv, "01", &flags);
 
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
-
-    gen_call_void(virStoragePoolBuild, conn(p), pool_get(p), NUM2UINT(flags));
+    ruby_libvirt_generate_call_nil(virStoragePoolBuild,
+                                   ruby_libvirt_connect_get(p),
+                                   pool_get(p),
+                                   ruby_libvirt_value_to_uint(flags));
 }
 
 /*
  * call-seq:
  *   pool.undefine -> nil
  *
- * Call +virStoragePoolUndefine+[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolUndefine]
+ * Call virStoragePoolUndefine[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolUndefine]
  * to undefine this storage pool.
  */
-static VALUE libvirt_pool_undefine(VALUE p) {
-    gen_call_void(virStoragePoolUndefine, conn(p), pool_get(p));
+static VALUE libvirt_storage_pool_undefine(VALUE p)
+{
+    ruby_libvirt_generate_call_nil(virStoragePoolUndefine,
+                                   ruby_libvirt_connect_get(p),
+                                   pool_get(p));
 }
 
 /*
  * call-seq:
  *   pool.create(flags=0) -> nil
  *
- * Call +virStoragePoolCreate+[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolCreate]
+ * Call virStoragePoolCreate[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolCreate]
  * to start this storage pool.
  */
-static VALUE libvirt_pool_create(int argc, VALUE *argv, VALUE p) {
+static VALUE libvirt_storage_pool_create(int argc, VALUE *argv, VALUE p)
+{
     VALUE flags;
 
     rb_scan_args(argc, argv, "01", &flags);
 
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
-
-    gen_call_void(virStoragePoolCreate, conn(p), pool_get(p), NUM2UINT(flags));
+    ruby_libvirt_generate_call_nil(virStoragePoolCreate,
+                                   ruby_libvirt_connect_get(p),
+                                   pool_get(p),
+                                   ruby_libvirt_value_to_uint(flags));
 }
 
 /*
  * call-seq:
  *   pool.destroy -> nil
  *
- * Call +virStoragePoolDestroy+[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolDestroy]
+ * Call virStoragePoolDestroy[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolDestroy]
  * to shutdown this storage pool.
  */
-static VALUE libvirt_pool_destroy(VALUE p) {
-    gen_call_void(virStoragePoolDestroy, conn(p), pool_get(p));
+static VALUE libvirt_storage_pool_destroy(VALUE p)
+{
+    ruby_libvirt_generate_call_nil(virStoragePoolDestroy,
+                                   ruby_libvirt_connect_get(p),
+                                   pool_get(p));
 }
 
 /*
  * call-seq:
  *   pool.delete(flags=0) -> nil
  *
- * Call +virStoragePoolDelete+[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolDelete]
+ * Call virStoragePoolDelete[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolDelete]
  * to delete the data corresponding to this data pool.  This is a destructive
  * operation.
  */
-static VALUE libvirt_pool_delete(int argc, VALUE *argv, VALUE p) {
+static VALUE libvirt_storage_pool_delete(int argc, VALUE *argv, VALUE p)
+{
     VALUE flags;
 
     rb_scan_args(argc, argv, "01", &flags);
 
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
-
-    gen_call_void(virStoragePoolDelete, conn(p), pool_get(p), NUM2UINT(flags));
+    ruby_libvirt_generate_call_nil(virStoragePoolDelete,
+                                   ruby_libvirt_connect_get(p),
+                                   pool_get(p),
+                                   ruby_libvirt_value_to_uint(flags));
 }
 
 /*
  * call-seq:
  *   pool.refresh(flags=0) -> nil
  *
- * Call +virStoragePoolRefresh+[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolRefresh]
+ * Call virStoragePoolRefresh[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolRefresh]
  * to refresh the list of volumes in this storage pool.
  */
-static VALUE libvirt_pool_refresh(int argc, VALUE *argv, VALUE p) {
+static VALUE libvirt_storage_pool_refresh(int argc, VALUE *argv, VALUE p)
+{
     VALUE flags;
 
     rb_scan_args(argc, argv, "01", &flags);
 
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
-
-    gen_call_void(virStoragePoolRefresh, conn(p), pool_get(p), NUM2UINT(flags));
+    ruby_libvirt_generate_call_nil(virStoragePoolRefresh,
+                                   ruby_libvirt_connect_get(p),
+                                   pool_get(p),
+                                   ruby_libvirt_value_to_uint(flags));
 }
 
 /*
  * call-seq:
  *   pool.name -> string
  *
- * Call +virStoragePoolGetName+[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolGetName]
+ * Call virStoragePoolGetName[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolGetName]
  * to retrieve the name of this storage pool.
  */
-static VALUE libvirt_pool_name(VALUE s) {
-    gen_call_string(virStoragePoolGetName, conn(s), 0, pool_get(s));
+static VALUE libvirt_storage_pool_name(VALUE p)
+{
+    ruby_libvirt_generate_call_string(virStoragePoolGetName,
+                                      ruby_libvirt_connect_get(p), 0,
+                                      pool_get(p));
 }
 
 /*
  * call-seq:
  *   pool.uuid -> string
  *
- * Call +virStoragePoolGetUUIDString+[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolGetUUIDString]
+ * Call virStoragePoolGetUUIDString[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolGetUUIDString]
  * to retrieve the UUID of this storage pool.
  */
-static VALUE libvirt_pool_uuid(VALUE s) {
-    char uuid[VIR_UUID_STRING_BUFLEN];
-    int r;
-
-    r = virStoragePoolGetUUIDString(pool_get(s), uuid);
-    _E(r < 0, create_error(e_RetrieveError, "virStoragePoolGetUUIDString",
-                           conn(s)));
-
-    return rb_str_new2((char *) uuid);
+static VALUE libvirt_storage_pool_uuid(VALUE p)
+{
+    ruby_libvirt_generate_uuid(virStoragePoolGetUUIDString,
+                               ruby_libvirt_connect_get(p), pool_get(p));
 }
 
 /*
  * call-seq:
  *   pool.info -> Libvirt::StoragePoolInfo
  *
- * Call +virStoragePoolGetInfo+[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolGetInfo]
+ * Call virStoragePoolGetInfo[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolGetInfo]
  * to retrieve information about this storage pool.
  */
-static VALUE libvirt_pool_info(VALUE s) {
+static VALUE libvirt_storage_pool_info(VALUE p)
+{
     virStoragePoolInfo info;
     int r;
     VALUE result;
 
-    r = virStoragePoolGetInfo(pool_get(s), &info);
-    _E(r < 0, create_error(e_RetrieveError, "virStoragePoolGetInfo", conn(s)));
+    r = virStoragePoolGetInfo(pool_get(p), &info);
+    ruby_libvirt_raise_error_if(r < 0, e_RetrieveError,
+                                "virStoragePoolGetInfo",
+                                ruby_libvirt_connect_get(p));
 
     result = rb_class_new_instance(0, NULL, c_storage_pool_info);
     rb_iv_set(result, "@state", INT2NUM(info.state));
@@ -224,34 +242,36 @@ static VALUE libvirt_pool_info(VALUE s) {
  * call-seq:
  *   pool.xml_desc(flags=0) -> string
  *
- * Call +virStoragePoolGetXMLDesc+[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolGetXMLDesc]
+ * Call virStoragePoolGetXMLDesc[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolGetXMLDesc]
  * to retrieve the XML for this storage pool.
  */
-static VALUE libvirt_pool_xml_desc(int argc, VALUE *argv, VALUE s) {
+static VALUE libvirt_storage_pool_xml_desc(int argc, VALUE *argv, VALUE p)
+{
     VALUE flags;
 
     rb_scan_args(argc, argv, "01", &flags);
 
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
-
-    gen_call_string(virStoragePoolGetXMLDesc, conn(s), 1, pool_get(s),
-                    NUM2UINT(flags));
+    ruby_libvirt_generate_call_string(virStoragePoolGetXMLDesc,
+                                      ruby_libvirt_connect_get(p),
+                                      1, pool_get(p),
+                                      ruby_libvirt_value_to_uint(flags));
 }
 
 /*
  * call-seq:
  *   pool.autostart? -> [true|false]
  *
- * Call +virStoragePoolGetAutostart+[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolGetAutostart]
+ * Call virStoragePoolGetAutostart[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolGetAutostart]
  * to determine whether this storage pool will autostart when libvirtd starts.
  */
-static VALUE libvirt_pool_autostart(VALUE s){
+static VALUE libvirt_storage_pool_autostart(VALUE p)
+{
     int r, autostart;
 
-    r = virStoragePoolGetAutostart(pool_get(s), &autostart);
-    _E(r < 0, create_error(e_RetrieveError, "virStoragePoolGetAutostart",
-                           conn(s)));
+    r = virStoragePoolGetAutostart(pool_get(p), &autostart);
+    ruby_libvirt_raise_error_if(r < 0, e_RetrieveError,
+                                "virStoragePoolGetAutostart",
+                                ruby_libvirt_connect_get(p));
 
     return autostart ? Qtrue : Qfalse;
 }
@@ -260,29 +280,36 @@ static VALUE libvirt_pool_autostart(VALUE s){
  * call-seq:
  *   pool.autostart = [true|false]
  *
- * Call +virStoragePoolSetAutostart+[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolSetAutostart]
+ * Call virStoragePoolSetAutostart[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolSetAutostart]
  * to make this storage pool start when libvirtd starts.
  */
-static VALUE libvirt_pool_autostart_set(VALUE s, VALUE autostart) {
-    if (autostart != Qtrue && autostart != Qfalse)
+static VALUE libvirt_storage_pool_autostart_equal(VALUE p, VALUE autostart)
+{
+    if (autostart != Qtrue && autostart != Qfalse) {
 		rb_raise(rb_eTypeError,
                  "wrong argument type (expected TrueClass or FalseClass)");
+    }
 
-    gen_call_void(virStoragePoolSetAutostart, conn(s), pool_get(s),
-                  RTEST(autostart) ? 1 : 0);
+    ruby_libvirt_generate_call_nil(virStoragePoolSetAutostart,
+                                   ruby_libvirt_connect_get(p),
+                                   pool_get(p), RTEST(autostart) ? 1 : 0);
 }
 
 /*
  * call-seq:
  *   pool.num_of_volumes -> fixnum
  *
- * Call +virStoragePoolNumOfVolumes+[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolNumOfVolumes]
+ * Call virStoragePoolNumOfVolumes[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolNumOfVolumes]
  * to retrieve the number of volumes in this storage pool.
  */
-static VALUE libvirt_pool_num_of_volumes(VALUE s) {
-    int n = virStoragePoolNumOfVolumes(pool_get(s));
-    _E(n < 0, create_error(e_RetrieveError, "virStoragePoolNumOfVolumes",
-                           conn(s)));
+static VALUE libvirt_storage_pool_num_of_volumes(VALUE p)
+{
+    int n;
+
+    n = virStoragePoolNumOfVolumes(pool_get(p));
+    ruby_libvirt_raise_error_if(n < 0, e_RetrieveError,
+                                "virStoragePoolNumOfVolumes",
+                                ruby_libvirt_connect_get(p));
 
     return INT2NUM(n);
 }
@@ -291,41 +318,42 @@ static VALUE libvirt_pool_num_of_volumes(VALUE s) {
  * call-seq:
  *   pool.list_volumes -> list
  *
- * Call +virStoragePoolListVolumes+[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolListVolumes]
+ * Call virStoragePoolListVolumes[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolListVolumes]
  * to retrieve a list of volume names in this storage pools.
  */
-static VALUE libvirt_pool_list_volumes(VALUE s) {
+static VALUE libvirt_storage_pool_list_volumes(VALUE p)
+{
     int r, num;
     char **names;
-    virStoragePoolPtr pool = pool_get(s);
 
-    num = virStoragePoolNumOfVolumes(pool);
-    _E(num < 0, create_error(e_RetrieveError, "virStoragePoolNumOfVolumes",
-                             conn(s)));
-    if (num == 0)
+    num = virStoragePoolNumOfVolumes(pool_get(p));
+    ruby_libvirt_raise_error_if(num < 0, e_RetrieveError,
+                                "virStoragePoolNumOfVolumes",
+                                ruby_libvirt_connect_get(p));
+    if (num == 0) {
         return rb_ary_new2(num);
-
-    names = ALLOC_N(char *, num);
-    r = virStoragePoolListVolumes(pool, names, num);
-    if (r < 0) {
-        xfree(names);
-        rb_exc_raise(create_error(e_RetrieveError, "virStoragePoolListVolumes",
-                                  conn(s)));
     }
 
-    return gen_list(num, &names);
+    names = alloca(sizeof(char *) * num);
+    r = virStoragePoolListVolumes(pool_get(p), names, num);
+    ruby_libvirt_raise_error_if(r < 0, e_RetrieveError,
+                                "virStoragePoolListVolumes",
+                                ruby_libvirt_connect_get(p));
+
+    return ruby_libvirt_generate_list(num, names);
 }
 
 /*
  * call-seq:
  *   pool.free -> nil
  *
- * Call +virStoragePoolFree+[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolFree]
+ * Call virStoragePoolFree[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolFree]
  * to free this storage pool object.  After this call the storage pool object
  * is no longer valid.
  */
-static VALUE libvirt_pool_free(VALUE s) {
-    gen_call_free(StoragePool, s);
+static VALUE libvirt_storage_pool_free(VALUE p)
+{
+    ruby_libvirt_generate_call_free(StoragePool, p);
 }
 #endif
 
@@ -336,111 +364,144 @@ static VALUE libvirt_pool_free(VALUE s) {
 static VALUE c_storage_vol;
 static VALUE c_storage_vol_info;
 
-static void vol_free(void *d) {
-    generic_free(StorageVol, d);
+static void vol_free(void *d)
+{
+    ruby_libvirt_free_struct(StorageVol, d);
 }
 
-static VALUE vol_new(virStorageVolPtr n, VALUE conn) {
-    return generic_new(c_storage_vol, n, conn, vol_free);
+static VALUE vol_new(virStorageVolPtr v, VALUE conn)
+{
+    return ruby_libvirt_new_class(c_storage_vol, v, conn, vol_free);
 }
 
 /*
  * call-seq:
  *   pool.lookup_volume_by_name(name) -> Libvirt::StorageVol
  *
- * Call +virStorageVolLookupByName+[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolLookupByName]
+ * Call virStorageVolLookupByName[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolLookupByName]
  * to retrieve a storage volume object by name.
  */
-static VALUE libvirt_pool_lookup_vol_by_name(VALUE p, VALUE name) {
+static VALUE libvirt_storage_pool_lookup_vol_by_name(VALUE p, VALUE name)
+{
     virStorageVolPtr vol;
 
     vol = virStorageVolLookupByName(pool_get(p), StringValueCStr(name));
-    _E(vol == NULL, create_error(e_RetrieveError, "virStorageVolLookupByName",
-                                 conn(p)));
+    ruby_libvirt_raise_error_if(vol == NULL, e_RetrieveError,
+                                "virStorageVolLookupByName",
+                                ruby_libvirt_connect_get(p));
 
-    return vol_new(vol, conn_attr(p));
+    return vol_new(vol, ruby_libvirt_conn_attr(p));
 }
 
 /*
  * call-seq:
  *   pool.lookup_volume_by_key(key) -> Libvirt::StorageVol
  *
- * Call +virStorageVolLookupByKey+[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolLookupByKey]
+ * Call virStorageVolLookupByKey[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolLookupByKey]
  * to retrieve a storage volume object by key.
  */
-static VALUE libvirt_pool_lookup_vol_by_key(VALUE p, VALUE key) {
+static VALUE libvirt_storage_pool_lookup_vol_by_key(VALUE p, VALUE key)
+{
     virStorageVolPtr vol;
 
     /* FIXME: Why does this take a connection, not a pool? */
-    vol = virStorageVolLookupByKey(conn(p), StringValueCStr(key));
-    _E(vol == NULL, create_error(e_RetrieveError, "virStorageVolLookupByKey",
-                                 conn(p)));
+    vol = virStorageVolLookupByKey(ruby_libvirt_connect_get(p),
+                                   StringValueCStr(key));
+    ruby_libvirt_raise_error_if(vol == NULL, e_RetrieveError,
+                                "virStorageVolLookupByKey",
+                                ruby_libvirt_connect_get(p));
 
-    return vol_new(vol, conn_attr(p));
+    return vol_new(vol, ruby_libvirt_conn_attr(p));
 }
 
 /*
  * call-seq:
  *   pool.lookup_volume_by_path(path) -> Libvirt::StorageVol
  *
- * Call +virStorageVolLookupByPath+[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolLookupByPath]
+ * Call virStorageVolLookupByPath[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolLookupByPath]
  * to retrieve a storage volume object by path.
  */
-static VALUE libvirt_pool_lookup_vol_by_path(VALUE p, VALUE path) {
+static VALUE libvirt_storage_pool_lookup_vol_by_path(VALUE p, VALUE path)
+{
     virStorageVolPtr vol;
 
     /* FIXME: Why does this take a connection, not a pool? */
-    vol = virStorageVolLookupByPath(conn(p), StringValueCStr(path));
-    _E(vol == NULL, create_error(e_RetrieveError, "virStorageVolLookupByPath",
-                                 conn(p)));
+    vol = virStorageVolLookupByPath(ruby_libvirt_connect_get(p),
+                                    StringValueCStr(path));
+    ruby_libvirt_raise_error_if(vol == NULL, e_RetrieveError,
+                                "virStorageVolLookupByPath",
+                                ruby_libvirt_connect_get(p));
+
+    return vol_new(vol, ruby_libvirt_conn_attr(p));
+}
 
-    return vol_new(vol, conn_attr(p));
+#if HAVE_VIRSTORAGEPOOLLISTALLVOLUMES
+/*
+ * call-seq:
+ *   pool.list_all_volumes(flags=0) -> array
+ *
+ * Call virStoragePoolListAllVolumes[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolListAllVolumes]
+ * to get an array of volume objects for all volumes.
+ */
+static VALUE libvirt_storage_pool_list_all_volumes(int argc, VALUE *argv,
+                                                   VALUE p)
+{
+    ruby_libvirt_generate_call_list_all(virStorageVolPtr, argc, argv,
+                                        virStoragePoolListAllVolumes,
+                                        pool_get(p), p, vol_new,
+                                        virStorageVolFree);
 }
+#endif
 
 /*
  * call-seq:
  *   vol.name -> string
  *
- * Call +virStorageVolGetName+[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolGetName]
+ * Call virStorageVolGetName[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolGetName]
  * to retrieve the name of this storage volume.
  */
-static VALUE libvirt_vol_name(VALUE v) {
-    gen_call_string(virStorageVolGetName, conn(v), 0, vol_get(v));
+static VALUE libvirt_storage_vol_name(VALUE v)
+{
+    ruby_libvirt_generate_call_string(virStorageVolGetName,
+                                      ruby_libvirt_connect_get(v), 0,
+                                      vol_get(v));
 }
 
 /*
  * call-seq:
  *   vol.key -> string
  *
- * Call +virStorageVolGetKey+[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolGetKey]
+ * Call virStorageVolGetKey[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolGetKey]
  * to retrieve the key for this storage volume.
  */
-static VALUE libvirt_vol_key(VALUE v) {
-    gen_call_string(virStorageVolGetKey, conn(v), 0, vol_get(v));
+static VALUE libvirt_storage_vol_key(VALUE v)
+{
+    ruby_libvirt_generate_call_string(virStorageVolGetKey,
+                                      ruby_libvirt_connect_get(v), 0,
+                                      vol_get(v));
 }
 
 /*
  * call-seq:
  *   pool.create_volume_xml(xml, flags=0) -> Libvirt::StorageVol
  *
- * Call +virStorageVolCreateXML+[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolCreateXML]
+ * Call virStorageVolCreateXML[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolCreateXML]
  * to create a new storage volume from xml.
  */
-static VALUE libvirt_pool_vol_create_xml(int argc, VALUE *argv, VALUE p) {
+static VALUE libvirt_storage_pool_create_volume_xml(int argc, VALUE *argv,
+                                                    VALUE p)
+{
     virStorageVolPtr vol;
-    virConnectPtr c = conn(p);
     VALUE xml, flags;
 
     rb_scan_args(argc, argv, "11", &xml, &flags);
 
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
-
     vol = virStorageVolCreateXML(pool_get(p), StringValueCStr(xml),
-                                 NUM2UINT(flags));
-    _E(vol == NULL, create_error(e_Error, "virNetworkCreateXML", c));
+                                 ruby_libvirt_value_to_uint(flags));
+    ruby_libvirt_raise_error_if(vol == NULL, e_Error, "virNetworkCreateXML",
+                                ruby_libvirt_connect_get(p));
 
-    return vol_new(vol, conn_attr(p));
+    return vol_new(vol, ruby_libvirt_conn_attr(p));
 }
 
 #if HAVE_VIRSTORAGEVOLCREATEXMLFROM
@@ -448,25 +509,26 @@ static VALUE libvirt_pool_vol_create_xml(int argc, VALUE *argv, VALUE p) {
  * call-seq:
  *   pool.create_volume_xml_from(xml, clonevol, flags=0) -> Libvirt::StorageVol
  *
- * Call +virStorageVolCreateXMLFrom+[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolCreateXMLFrom]
+ * Call virStorageVolCreateXMLFrom[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolCreateXMLFrom]
  * to clone a volume from an existing volume with the properties specified in
  * xml.
  */
-static VALUE libvirt_pool_vol_create_xml_from(int argc, VALUE *argv, VALUE p) {
+static VALUE libvirt_storage_pool_create_volume_xml_from(int argc, VALUE *argv,
+                                                         VALUE p)
+{
     virStorageVolPtr vol;
-    virConnectPtr c = conn(p);
     VALUE xml, flags, cloneval;
 
     rb_scan_args(argc, argv, "21", &xml, &cloneval, &flags);
 
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
-
     vol = virStorageVolCreateXMLFrom(pool_get(p), StringValueCStr(xml),
-                                     vol_get(cloneval), NUM2UINT(flags));
-    _E(vol == NULL, create_error(e_Error, "virNetworkCreateXMLFrom", c));
+                                     vol_get(cloneval),
+                                     ruby_libvirt_value_to_uint(flags));
+    ruby_libvirt_raise_error_if(vol == NULL, e_Error,
+                                "virNetworkCreateXMLFrom",
+                                ruby_libvirt_connect_get(p));
 
-    return vol_new(vol, conn_attr(p));
+    return vol_new(vol, ruby_libvirt_conn_attr(p));
 }
 #endif
 
@@ -475,11 +537,14 @@ static VALUE libvirt_pool_vol_create_xml_from(int argc, VALUE *argv, VALUE p) {
  * call-seq:
  *   pool.active? -> [true|false]
  *
- * Call +virStoragePoolIsActive+[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolIsActive]
+ * Call virStoragePoolIsActive[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolIsActive]
  * to determine if this storage pool is active.
  */
-static VALUE libvirt_pool_active_p(VALUE p) {
-    gen_call_truefalse(virStoragePoolIsActive, conn(p), pool_get(p));
+static VALUE libvirt_storage_pool_active_p(VALUE p)
+{
+    ruby_libvirt_generate_call_truefalse(virStoragePoolIsActive,
+                                         ruby_libvirt_connect_get(p),
+                                         pool_get(p));
 }
 #endif
 
@@ -488,11 +553,14 @@ static VALUE libvirt_pool_active_p(VALUE p) {
  * call-seq:
  *   pool.persistent? -> [true|false]
  *
- * Call +virStoragePoolIsPersistent+[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolIsPersistent]
+ * Call virStoragePoolIsPersistent[http://www.libvirt.org/html/libvirt-libvirt.html#virStoragePoolIsPersistent]
  * to determine if this storage pool is persistent.
  */
-static VALUE libvirt_pool_persistent_p(VALUE p) {
-    gen_call_truefalse(virStoragePoolIsPersistent, conn(p), pool_get(p));
+static VALUE libvirt_storage_pool_persistent_p(VALUE p)
+{
+    ruby_libvirt_generate_call_truefalse(virStoragePoolIsPersistent,
+                                         ruby_libvirt_connect_get(p),
+                                         pool_get(p));
 }
 #endif
 
@@ -500,18 +568,19 @@ static VALUE libvirt_pool_persistent_p(VALUE p) {
  * call-seq:
  *   vol.delete(flags=0) -> nil
  *
- * Call +virStorageVolDelete+[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolDelete]
+ * Call virStorageVolDelete[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolDelete]
  * to delete this volume.  This is a destructive operation.
  */
-static VALUE libvirt_vol_delete(int argc, VALUE *argv, VALUE v) {
+static VALUE libvirt_storage_vol_delete(int argc, VALUE *argv, VALUE v)
+{
     VALUE flags;
 
     rb_scan_args(argc, argv, "01", &flags);
 
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
-
-    gen_call_void(virStorageVolDelete, conn(v), vol_get(v), NUM2UINT(flags));
+    ruby_libvirt_generate_call_nil(virStorageVolDelete,
+                                   ruby_libvirt_connect_get(v),
+                                   vol_get(v),
+                                   ruby_libvirt_value_to_uint(flags));
 }
 
 #if HAVE_VIRSTORAGEVOLWIPE
@@ -519,18 +588,19 @@ static VALUE libvirt_vol_delete(int argc, VALUE *argv, VALUE v) {
  * call-seq:
  *   vol.wipe(flags=0) -> nil
  *
- * Call +virStorageVolWipe+[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolWipe]
+ * Call virStorageVolWipe[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolWipe]
  * to wipe the data from this storage volume.  This is a destructive operation.
  */
-static VALUE libvirt_vol_wipe(int argc, VALUE *argv, VALUE v) {
+static VALUE libvirt_storage_vol_wipe(int argc, VALUE *argv, VALUE v)
+{
     VALUE flags;
 
     rb_scan_args(argc, argv, "01", &flags);
 
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
-
-    gen_call_void(virStorageVolWipe, conn(v), vol_get(v), NUM2UINT(flags));
+    ruby_libvirt_generate_call_nil(virStorageVolWipe,
+                                   ruby_libvirt_connect_get(v),
+                                   vol_get(v),
+                                   ruby_libvirt_value_to_uint(flags));
 }
 #endif
 
@@ -538,16 +608,18 @@ static VALUE libvirt_vol_wipe(int argc, VALUE *argv, VALUE v) {
  * call-seq:
  *   vol.info -> Libvirt::StorageVolInfo
  *
- * Call +virStorageVolGetInfo+[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolGetInfo]
+ * Call virStorageVolGetInfo[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolGetInfo]
  * to retrieve information about this storage volume.
  */
-static VALUE libvirt_vol_info(VALUE v) {
+static VALUE libvirt_storage_vol_info(VALUE v)
+{
     virStorageVolInfo info;
     int r;
     VALUE result;
 
     r = virStorageVolGetInfo(vol_get(v), &info);
-    _E(r < 0, create_error(e_RetrieveError, "virStorageVolGetInfo", conn(v)));
+    ruby_libvirt_raise_error_if(r < 0, e_RetrieveError, "virStorageVolGetInfo",
+                                ruby_libvirt_connect_get(v));
 
     result = rb_class_new_instance(0, NULL, c_storage_vol_info);
     rb_iv_set(result, "@type", INT2NUM(info.type));
@@ -561,42 +633,46 @@ static VALUE libvirt_vol_info(VALUE v) {
  * call-seq:
  *   vol.xml_desc(flags=0) -> string
  *
- * Call +virStorageVolGetXMLDesc+[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolGetXMLDesc]
+ * Call virStorageVolGetXMLDesc[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolGetXMLDesc]
  * to retrieve the xml for this storage volume.
  */
-static VALUE libvirt_vol_xml_desc(int argc, VALUE *argv, VALUE v) {
+static VALUE libvirt_storage_vol_xml_desc(int argc, VALUE *argv, VALUE v)
+{
     VALUE flags;
 
     rb_scan_args(argc, argv, "01", &flags);
 
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
-
-    gen_call_string(virStorageVolGetXMLDesc, conn(v), 1, vol_get(v),
-                    NUM2UINT(flags));
+    ruby_libvirt_generate_call_string(virStorageVolGetXMLDesc,
+                                      ruby_libvirt_connect_get(v),
+                                      1, vol_get(v),
+                                      ruby_libvirt_value_to_uint(flags));
 }
 
 /*
  * call-seq:
  *   vol.path -> string
  *
- * Call +virStorageVolGetPath+[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolGetPath]
+ * Call virStorageVolGetPath[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolGetPath]
  * to retrieve the path for this storage volume.
  */
-static VALUE libvirt_vol_path(VALUE v) {
-    gen_call_string(virStorageVolGetPath, conn(v), 1, vol_get(v));
+static VALUE libvirt_storage_vol_path(VALUE v)
+{
+    ruby_libvirt_generate_call_string(virStorageVolGetPath,
+                                      ruby_libvirt_connect_get(v), 1,
+                                      vol_get(v));
 }
 
 /*
  * call-seq:
  *   vol.free -> nil
  *
- * Call +virStorageVolFree+[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolFree]
+ * Call virStorageVolFree[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolFree]
  * to free the storage volume object.  After this call the storage volume object
  * is no longer valid.
  */
-static VALUE libvirt_vol_free(VALUE s) {
-    gen_call_free(StorageVol, s);
+static VALUE libvirt_storage_vol_free(VALUE v)
+{
+    ruby_libvirt_generate_call_free(StorageVol, v);
 }
 #endif
 
@@ -605,42 +681,87 @@ static VALUE libvirt_vol_free(VALUE s) {
  * call-seq:
  *   vol.download(stream, offset, length, flags=0) -> nil
  *
- * Call +virStorageVolDownload+[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolDownload]
+ * Call virStorageVolDownload[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolDownload]
  * to download the content of a volume as a stream.
  */
-static VALUE libvirt_vol_download(int argc, VALUE *argv, VALUE v) {
+static VALUE libvirt_storage_vol_download(int argc, VALUE *argv, VALUE v)
+{
     VALUE st, offset, length, flags;
 
     rb_scan_args(argc, argv, "31", &st, &offset, &length, &flags);
 
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
-
-    gen_call_void(virStorageVolDownload, conn(v), vol_get(v), stream_get(st),
-                  NUM2ULL(offset), NUM2ULL(length), NUM2UINT(flags));
+    ruby_libvirt_generate_call_nil(virStorageVolDownload,
+                                   ruby_libvirt_connect_get(v),
+                                   vol_get(v), ruby_libvirt_stream_get(st),
+                                   NUM2ULL(offset), NUM2ULL(length),
+                                   ruby_libvirt_value_to_uint(flags));
 }
 
 /*
  * call-seq:
  *   vol.upload(stream, offset, length, flags=0) -> nil
  *
- * Call +virStorageVolUpload+[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolUpload]
+ * Call virStorageVolUpload[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolUpload]
  * to upload new content to a volume from a stream.
  */
-static VALUE libvirt_vol_upload(int argc, VALUE *argv, VALUE v) {
+static VALUE libvirt_storage_vol_upload(int argc, VALUE *argv, VALUE v)
+{
     VALUE st, offset, length, flags;
 
     rb_scan_args(argc, argv, "31", &st, &offset, &length, &flags);
 
-    if (NIL_P(flags))
-        flags = INT2NUM(0);
+    ruby_libvirt_generate_call_nil(virStorageVolUpload,
+                                   ruby_libvirt_connect_get(v),
+                                   vol_get(v), ruby_libvirt_stream_get(st),
+                                   NUM2ULL(offset), NUM2ULL(length),
+                                   ruby_libvirt_value_to_uint(flags));
+}
+#endif
+
+#if HAVE_VIRSTORAGEVOLWIPEPATTERN
+/*
+ * call-seq:
+ *   vol.wipe_pattern(alg, flags=0) -> nil
+ *
+ * Call virStorageVolWipePattern[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolWipePattern]
+ * to wipe the data from this storage volume.  This is a destructive operation.
+ */
+static VALUE libvirt_storage_vol_wipe_pattern(int argc, VALUE *argv, VALUE v)
+{
+    VALUE alg, flags;
+
+    rb_scan_args(argc, argv, "11", &alg, &flags);
 
-    gen_call_void(virStorageVolUpload, conn(v), vol_get(v), stream_get(st),
-                  NUM2ULL(offset), NUM2ULL(length), NUM2UINT(flags));
+    ruby_libvirt_generate_call_nil(virStorageVolWipePattern,
+                                   ruby_libvirt_connect_get(v),
+                                   vol_get(v), NUM2UINT(alg),
+                                   ruby_libvirt_value_to_uint(flags));
 }
 #endif
 
-void init_storage(void) {
+#if HAVE_VIRSTORAGEVOLRESIZE
+/*
+ * call-seq:
+ *   vol.resize(capacity, flags=0) -> nil
+ *
+ * Call virStorageVolResize[http://www.libvirt.org/html/libvirt-libvirt.html#virStorageVolResize]
+ * to resize the associated storage volume.
+ */
+static VALUE libvirt_storage_vol_resize(int argc, VALUE *argv, VALUE v)
+{
+    VALUE capacity, flags;
+
+    rb_scan_args(argc, argv, "11", &capacity, &flags);
+
+    ruby_libvirt_generate_call_nil(virStorageVolResize,
+                                   ruby_libvirt_connect_get(v),
+                                   vol_get(v), NUM2ULL(capacity),
+                                   ruby_libvirt_value_to_uint(flags));
+}
+#endif
+
+void ruby_libvirt_storage_init(void)
+{
     /*
      * Class Libvirt::StoragePool and Libvirt::StoragePoolInfo
      */
@@ -671,6 +792,11 @@ void init_storage(void) {
                     INT2NUM(VIR_STORAGE_POOL_INACCESSIBLE));
 #endif
 
+#if HAVE_CONST_VIR_STORAGE_XML_INACTIVE
+    rb_define_const(c_storage_pool, "XML_INACTIVE",
+                    INT2NUM(VIR_STORAGE_XML_INACTIVE));
+#endif
+
     /* virStoragePoolBuildFlags */
     rb_define_const(c_storage_pool, "BUILD_NEW",
                     INT2NUM(VIR_STORAGE_POOL_BUILD_NEW));
@@ -685,51 +811,79 @@ void init_storage(void) {
     rb_define_const(c_storage_pool, "DELETE_ZEROED",
                     INT2NUM(VIR_STORAGE_POOL_DELETE_ZEROED));
 
+#if HAVE_CONST_VIR_STORAGE_VOL_CREATE_PREALLOC_METADATA
+    rb_define_const(c_storage_pool, "CREATE_PREALLOC_METADATA",
+                    INT2NUM(VIR_STORAGE_VOL_CREATE_PREALLOC_METADATA));
+#endif
+
     /* Creating/destroying pools */
-    rb_define_method(c_storage_pool, "build", libvirt_pool_build, -1);
-    rb_define_method(c_storage_pool, "undefine", libvirt_pool_undefine, 0);
-    rb_define_method(c_storage_pool, "create", libvirt_pool_create, -1);
-    rb_define_method(c_storage_pool, "destroy", libvirt_pool_destroy, 0);
-    rb_define_method(c_storage_pool, "delete", libvirt_pool_delete, -1);
-    rb_define_method(c_storage_pool, "refresh", libvirt_pool_refresh, -1);
+    rb_define_method(c_storage_pool, "build", libvirt_storage_pool_build, -1);
+    rb_define_method(c_storage_pool, "undefine", libvirt_storage_pool_undefine,
+                     0);
+    rb_define_method(c_storage_pool, "create", libvirt_storage_pool_create, -1);
+    rb_define_method(c_storage_pool, "destroy", libvirt_storage_pool_destroy,
+                     0);
+    rb_define_method(c_storage_pool, "delete", libvirt_storage_pool_delete, -1);
+    rb_define_method(c_storage_pool, "refresh", libvirt_storage_pool_refresh,
+                     -1);
     /* StoragePool information */
-    rb_define_method(c_storage_pool, "name", libvirt_pool_name, 0);
-    rb_define_method(c_storage_pool, "uuid", libvirt_pool_uuid, 0);
-    rb_define_method(c_storage_pool, "info", libvirt_pool_info, 0);
-    rb_define_method(c_storage_pool, "xml_desc", libvirt_pool_xml_desc, -1);
-    rb_define_method(c_storage_pool, "autostart", libvirt_pool_autostart, 0);
-    rb_define_method(c_storage_pool, "autostart?", libvirt_pool_autostart, 0);
+    rb_define_method(c_storage_pool, "name", libvirt_storage_pool_name, 0);
+    rb_define_method(c_storage_pool, "uuid", libvirt_storage_pool_uuid, 0);
+    rb_define_method(c_storage_pool, "info", libvirt_storage_pool_info, 0);
+    rb_define_method(c_storage_pool, "xml_desc", libvirt_storage_pool_xml_desc,
+                     -1);
+    rb_define_method(c_storage_pool, "autostart",
+                     libvirt_storage_pool_autostart, 0);
+    rb_define_method(c_storage_pool, "autostart?",
+                     libvirt_storage_pool_autostart, 0);
     rb_define_method(c_storage_pool, "autostart=",
-                     libvirt_pool_autostart_set, 1);
+                     libvirt_storage_pool_autostart_equal, 1);
     /* List/lookup storage volumes within a pool */
     rb_define_method(c_storage_pool, "num_of_volumes",
-                     libvirt_pool_num_of_volumes, 0);
+                     libvirt_storage_pool_num_of_volumes, 0);
     rb_define_method(c_storage_pool, "list_volumes",
-                     libvirt_pool_list_volumes, 0);
+                     libvirt_storage_pool_list_volumes, 0);
     /* Lookup volumes based on various attributes */
     rb_define_method(c_storage_pool, "lookup_volume_by_name",
-                     libvirt_pool_lookup_vol_by_name, 1);
+                     libvirt_storage_pool_lookup_vol_by_name, 1);
     rb_define_method(c_storage_pool, "lookup_volume_by_key",
-                     libvirt_pool_lookup_vol_by_key, 1);
+                     libvirt_storage_pool_lookup_vol_by_key, 1);
     rb_define_method(c_storage_pool, "lookup_volume_by_path",
-                     libvirt_pool_lookup_vol_by_path, 1);
-    rb_define_method(c_storage_pool, "free", libvirt_pool_free, 0);
-    rb_define_method(c_storage_pool, "create_vol_xml",
-                     libvirt_pool_vol_create_xml, -1);
-    rb_define_alias(c_storage_pool, "create_volume_xml", "create_vol_xml");
+                     libvirt_storage_pool_lookup_vol_by_path, 1);
+    rb_define_method(c_storage_pool, "free", libvirt_storage_pool_free, 0);
+    rb_define_method(c_storage_pool, "create_volume_xml",
+                     libvirt_storage_pool_create_volume_xml, -1);
+    rb_define_alias(c_storage_pool, "create_vol_xml", "create_volume_xml");
 #if HAVE_VIRSTORAGEVOLCREATEXMLFROM
-    rb_define_method(c_storage_pool, "create_vol_xml_from",
-                     libvirt_pool_vol_create_xml_from, -1);
-    rb_define_alias(c_storage_pool, "create_volume_xml_from",
-                    "create_vol_xml_from");
+    rb_define_method(c_storage_pool, "create_volume_xml_from",
+                     libvirt_storage_pool_create_volume_xml_from, -1);
+    rb_define_alias(c_storage_pool, "create_vol_xml_from",
+                    "create_volume_xml_from");
 #endif
 #if HAVE_VIRSTORAGEPOOLISACTIVE
-    rb_define_method(c_storage_pool, "active?", libvirt_pool_active_p, 0);
+    rb_define_method(c_storage_pool, "active?", libvirt_storage_pool_active_p,
+                     0);
 #endif
 #if HAVE_VIRSTORAGEPOOLISPERSISTENT
     rb_define_method(c_storage_pool, "persistent?",
-                     libvirt_pool_persistent_p, 0);
+                     libvirt_storage_pool_persistent_p, 0);
 #endif
+
+#if HAVE_VIRSTORAGEPOOLLISTALLVOLUMES
+    rb_define_method(c_storage_pool, "list_all_volumes",
+                     libvirt_storage_pool_list_all_volumes, -1);
+#endif
+
+#if HAVE_CONST_VIR_STORAGE_POOL_BUILD_NO_OVERWRITE
+    rb_define_const(c_storage_pool, "BUILD_NO_OVERWRITE",
+                    INT2NUM(VIR_STORAGE_POOL_BUILD_NO_OVERWRITE));
+#endif
+
+#if HAVE_CONST_VIR_STORAGE_POOL_BUILD_OVERWRITE
+    rb_define_const(c_storage_pool, "BUILD_OVERWRITE",
+                    INT2NUM(VIR_STORAGE_POOL_BUILD_OVERWRITE));
+#endif
+
 #endif
 
 #if HAVE_TYPE_VIRSTORAGEVOLPTR
@@ -745,9 +899,20 @@ void init_storage(void) {
     c_storage_vol = rb_define_class_under(m_libvirt, "StorageVol",
                                           rb_cObject);
 
+#if HAVE_CONST_VIR_STORAGE_XML_INACTIVE
+    rb_define_const(c_storage_vol, "XML_INACTIVE",
+                    INT2NUM(VIR_STORAGE_XML_INACTIVE));
+#endif
+
     /* virStorageVolType */
     rb_define_const(c_storage_vol, "FILE", INT2NUM(VIR_STORAGE_VOL_FILE));
     rb_define_const(c_storage_vol, "BLOCK", INT2NUM(VIR_STORAGE_VOL_BLOCK));
+#if HAVE_CONST_VIR_STORAGE_VOL_DIR
+    rb_define_const(c_storage_vol, "DIR", INT2NUM(VIR_STORAGE_VOL_DIR));
+#endif
+#if HAVE_CONST_VIR_STORAGE_VOL_NETWORK
+    rb_define_const(c_storage_vol, "NETWORK", INT2NUM(VIR_STORAGE_VOL_NETWORK));
+#endif
 
     /* virStorageVolDeleteFlags */
     rb_define_const(c_storage_vol, "DELETE_NORMAL",
@@ -755,21 +920,74 @@ void init_storage(void) {
     rb_define_const(c_storage_vol, "DELETE_ZEROED",
                     INT2NUM(VIR_STORAGE_VOL_DELETE_ZEROED));
 
-    rb_define_method(c_storage_vol, "pool", libvirt_vol_get_pool, 0);
-    rb_define_method(c_storage_vol, "name", libvirt_vol_name, 0);
-    rb_define_method(c_storage_vol, "key", libvirt_vol_key, 0);
-    rb_define_method(c_storage_vol, "delete", libvirt_vol_delete, -1);
+    rb_define_method(c_storage_vol, "pool", libvirt_storage_vol_pool, 0);
+    rb_define_method(c_storage_vol, "name", libvirt_storage_vol_name, 0);
+    rb_define_method(c_storage_vol, "key", libvirt_storage_vol_key, 0);
+    rb_define_method(c_storage_vol, "delete", libvirt_storage_vol_delete, -1);
 #if HAVE_VIRSTORAGEVOLWIPE
-    rb_define_method(c_storage_vol, "wipe", libvirt_vol_wipe, -1);
+    rb_define_method(c_storage_vol, "wipe", libvirt_storage_vol_wipe, -1);
+#endif
+#if HAVE_VIRSTORAGEVOLWIPEPATTERN
+    rb_define_method(c_storage_vol, "wipe_pattern",
+                     libvirt_storage_vol_wipe_pattern, -1);
+#endif
+#if HAVE_CONST_VIR_STORAGE_VOL_WIPE_ALG_ZERO
+    rb_define_const(c_storage_vol, "WIPE_ALG_ZERO",
+                    INT2NUM(VIR_STORAGE_VOL_WIPE_ALG_ZERO));
+#endif
+#if HAVE_CONST_VIR_STORAGE_VOL_WIPE_ALG_NNSA
+    rb_define_const(c_storage_vol, "WIPE_ALG_NNSA",
+                    INT2NUM(VIR_STORAGE_VOL_WIPE_ALG_NNSA));
+#endif
+#if HAVE_CONST_VIR_STORAGE_VOL_WIPE_ALG_DOD
+    rb_define_const(c_storage_vol, "WIPE_ALG_DOD",
+                    INT2NUM(VIR_STORAGE_VOL_WIPE_ALG_DOD));
+#endif
+#if HAVE_CONST_VIR_STORAGE_VOL_WIPE_ALG_BSI
+    rb_define_const(c_storage_vol, "WIPE_ALG_BSI",
+                    INT2NUM(VIR_STORAGE_VOL_WIPE_ALG_BSI));
 #endif
-    rb_define_method(c_storage_vol, "info", libvirt_vol_info, 0);
-    rb_define_method(c_storage_vol, "xml_desc", libvirt_vol_xml_desc, -1);
-    rb_define_method(c_storage_vol, "path", libvirt_vol_path, 0);
-    rb_define_method(c_storage_vol, "free", libvirt_vol_free, 0);
+#if HAVE_CONST_VIR_STORAGE_VOL_WIPE_ALG_GUTMANN
+    rb_define_const(c_storage_vol, "WIPE_ALG_GUTMANN",
+                    INT2NUM(VIR_STORAGE_VOL_WIPE_ALG_GUTMANN));
+#endif
+#if HAVE_CONST_VIR_STORAGE_VOL_WIPE_ALG_SCHNEIER
+    rb_define_const(c_storage_vol, "WIPE_ALG_SCHNEIER",
+                    INT2NUM(VIR_STORAGE_VOL_WIPE_ALG_SCHNEIER));
+#endif
+#if HAVE_CONST_VIR_STORAGE_VOL_WIPE_ALG_PFITZNER7
+    rb_define_const(c_storage_vol, "WIPE_ALG_PFITZNER7",
+                    INT2NUM(VIR_STORAGE_VOL_WIPE_ALG_PFITZNER7));
+#endif
+#if HAVE_CONST_VIR_STORAGE_VOL_WIPE_ALG_PFITZNER33
+    rb_define_const(c_storage_vol, "WIPE_ALG_PFITZNER33",
+                    INT2NUM(VIR_STORAGE_VOL_WIPE_ALG_PFITZNER33));
+#endif
+#if HAVE_CONST_VIR_STORAGE_VOL_WIPE_ALG_RANDOM
+    rb_define_const(c_storage_vol, "WIPE_ALG_RANDOM",
+                    INT2NUM(VIR_STORAGE_VOL_WIPE_ALG_RANDOM));
+#endif
+
+    rb_define_method(c_storage_vol, "info", libvirt_storage_vol_info, 0);
+    rb_define_method(c_storage_vol, "xml_desc", libvirt_storage_vol_xml_desc,
+                     -1);
+    rb_define_method(c_storage_vol, "path", libvirt_storage_vol_path, 0);
+    rb_define_method(c_storage_vol, "free", libvirt_storage_vol_free, 0);
 
 #if HAVE_VIRSTORAGEVOLDOWNLOAD
-    rb_define_method(c_storage_vol, "download", libvirt_vol_download, -1);
-    rb_define_method(c_storage_vol, "upload", libvirt_vol_upload, -1);
+    rb_define_method(c_storage_vol, "download", libvirt_storage_vol_download,
+                     -1);
+    rb_define_method(c_storage_vol, "upload", libvirt_storage_vol_upload, -1);
+#endif
+
+#if HAVE_VIRSTORAGEVOLRESIZE
+    rb_define_const(c_storage_vol, "RESIZE_ALLOCATE",
+                    INT2NUM(VIR_STORAGE_VOL_RESIZE_ALLOCATE));
+    rb_define_const(c_storage_vol, "RESIZE_DELTA",
+                    INT2NUM(VIR_STORAGE_VOL_RESIZE_DELTA));
+    rb_define_const(c_storage_vol, "RESIZE_SHRINK",
+                    INT2NUM(VIR_STORAGE_VOL_RESIZE_SHRINK));
+    rb_define_method(c_storage_vol, "resize", libvirt_storage_vol_resize, -1);
 #endif
 
 #endif