Index: src/org/libvirt/Connect.java
===================================================================
RCS file: /data/cvs/libvirt-java/src/org/libvirt/Connect.java,v
retrieving revision 1.1
diff -u -r1.1 Connect.java
--- src/org/libvirt/Connect.java	18 Jul 2008 14:37:21 -0000	1.1
+++ src/org/libvirt/Connect.java	2 Aug 2008 15:21:11 -0000
@@ -1,5 +1,9 @@
 package org.libvirt;
 
+import org.libvirt.LibvirtException;
+import org.libvirt.StoragePool;
+import org.libvirt.StorageVol;
+
 /**
  * The Connect object represents a connection to a local or remote hypervisor/driver.
  *
@@ -541,4 +545,157 @@
 
 	private native int _setDom0Memory(long memory) throws LibvirtException;
 
+	/**
+	 * Provides the number of inactive storage pools
+	 * 
+	 * @return the number of pools found
+	 * @throws LibvirtException
+	 */
+	public int numOfDefinedStoragePools() throws LibvirtException {
+		return _numOfDefinedStoragePools(VCP);
+	}
+
+	private native int _numOfDefinedStoragePools(long VCP) throws LibvirtException;
+
+	/**
+	 * Provides the number of active storage pools
+	 * 
+	 * @return the number of pools found
+	 * @throws LibvirtException
+	 */
+	public int numOfStoragePools() throws LibvirtException {
+		return _numOfStoragePools(VCP);
+	}
+
+	private native int _numOfStoragePools(long VCP) throws LibvirtException;
+
+	/**
+	 * Provides the list of names of inactive storage pools.
+	 *
+	 * @return an Array of Strings that contains the names of the defined storage pools
+	 * @throws LibvirtException
+	 */
+	public String[] listDefinedStoragePools() throws LibvirtException {
+		return _listDefinedStoragePools(VCP);
+	}
+
+	private native String[] _listDefinedStoragePools(long VCP)
+	throws LibvirtException;
+
+	/**
+	 * Provides the list of names of active storage pools.
+	 *
+	 * @return an Array of Strings that contains the names of the defined storage pools
+	 * @throws LibvirtException
+	 */
+	public String[] listStoragePools() throws LibvirtException {
+		return _listStoragePools(VCP);
+	}
+
+	private native String[] _listStoragePools(long VCP)
+	throws LibvirtException;
+	
+	/**
+	 * Create a new storage based on its XML description. 
+	 * The pool is not persistent, so its definition will disappear when it is destroyed, or if the host is restarted
+	 * 
+	 * @param xmlDesc XML description for new pool
+	 * @param flags future flags, use 0 for now
+	 * @return StoragePool object
+	 * @throws LibvirtException
+	 */
+	public StoragePool storagePoolCreateXML(String xmlDesc, int flags)
+	throws LibvirtException {
+		return new StoragePool(this, _virStoragePoolCreateXML(VCP, xmlDesc, flags));
+	}
+
+	private native long _virStoragePoolCreateXML(long VCP, String xmlDesc, int flags)
+	throws LibvirtException;
+	
+	/**
+	 * Define a new inactive storage pool based on its XML description. 
+	 * The pool is persistent, until explicitly undefined.
+	 * 
+	 * @param xmlDesc XML description for new pool
+	 * @param flags flags future flags, use 0 for now
+	 * @return StoragePool object
+	 * @throws LibvirtException
+	 */
+	public StoragePool storagePoolDefineXML(String xml, int flags)
+	throws LibvirtException {
+		return new StoragePool(this, _virStoragePoolDefineXML(VCP, xml, flags));
+	}
+
+	private native long _virStoragePoolDefineXML(long VCP, String xml, int flags)
+	throws LibvirtException;
+
+	/**
+	 * Fetch a storage pool based on its unique name
+	 * 
+	 * @param name name of pool to fetch
+	 * @return StoragePool object
+	 * @throws LibvirtException
+	 */
+	public StoragePool storagePoolLookupByName(String name)
+	throws LibvirtException {
+		return new StoragePool(this, _virStoragePoolLookupByName(VCP, name));
+	}
+
+	private native long _virStoragePoolLookupByName(long VCP, String name)
+	throws LibvirtException;
+
+	/**
+	 * Fetch a storage pool based on its globally unique id
+	 * 
+	 * @param UUID globally unique id of pool to fetch
+	 * @return a new network object
+	 * @throws LibvirtException
+	 */
+	public StoragePool storagePoolLookupByUUID(int[] UUID)
+	throws LibvirtException {
+		return new StoragePool(this, _virStoragePoolLookupByUUID(VCP, UUID));
+	}
+
+	private native long _virStoragePoolLookupByUUID(long VCP, int[] UUID);
+	
+	/**
+	 * Fetch a storage pool based on its globally unique id
+	 * 
+	 * @param UUID globally unique id of pool to fetch
+	 * @return VirStoragePool object
+	 * @throws LibvirtException
+	 */
+	public StoragePool storagePoolLookupByUUIDString(String UUID)
+	throws LibvirtException {
+		return new StoragePool(this, _virStoragePoolLookupByUUIDString(VCP, UUID));
+	}
+
+	private native long _virStoragePoolLookupByUUIDString(long VCP, String UUID)
+	throws LibvirtException;
+	
+	/**
+	 * Fetch a a storage volume based on its globally unique key
+	 * 
+	 * @param key globally unique key
+	 * @return a storage volume
+	 */
+	public StorageVol storageVolLookupByKey(String key){
+		return new StorageVol(this, _virStorageVolLookupByKey(VCP, key));
+	}
+	
+	private native long _virStorageVolLookupByKey(long VCP, String key);
+	
+	/**
+	 * Fetch a storage volume based on its locally (host) unique path
+	 * 
+	 * @param path locally unique path
+	 * @return 	a storage volume
+	 */
+	public StorageVol storageVolLookupByPath(String path){
+		return new StorageVol(this, _virStorageVolLookupByPath(VCP, path));
+	}
+	
+	private native long _virStorageVolLookupByPath(long VCP, String path);
+
+
 }
Index: src/jni/org_libvirt_Connect.c
===================================================================
RCS file: /data/cvs/libvirt-java/src/jni/org_libvirt_Connect.c,v
retrieving revision 1.2
diff -u -r1.2 org_libvirt_Connect.c
--- src/jni/org_libvirt_Connect.c	22 Jul 2008 08:27:42 -0000	1.2
+++ src/jni/org_libvirt_Connect.c	2 Aug 2008 15:21:11 -0000
@@ -6,7 +6,8 @@
 
 #include <assert.h>
 
-//TODO We are leaking UTFChars all over the place. We need to strcpy, then release every string we get from JAVA, and not use them directly!
+//TODO We are leaking UTFChars all over the place. We need to release every string we get from JAVA with ReleaseStringUTFChars! (Done)
+//TODO The same for *ArrayElements
 
 JNIEXPORT jint JNICALL Java_org_libvirt_Connect__1virInitialize
   (JNIEnv *env, jclass cls){
@@ -47,8 +48,11 @@
 }
 
 JNIEXPORT jint JNICALL Java_org_libvirt_Connect__1getMaxVcpus
-  (JNIEnv *env, jobject obj, jlong VCP, jstring type){
-	return virConnectGetMaxVcpus((virConnectPtr)VCP , (*env)->GetStringUTFChars(env, type, NULL));
+  (JNIEnv *env, jobject obj, jlong VCP, jstring j_type){
+	const char *type = (*env)->GetStringUTFChars(env, j_type, NULL);
+	int retval = (jlong)virConnectGetMaxVcpus((virConnectPtr)VCP, type);
+	(*env)->ReleaseStringUTFChars(env, j_type, type);
+	return retval;
 };
 
 JNIEXPORT jstring JNICALL Java_org_libvirt_Connect__1getType
@@ -76,7 +80,7 @@
 JNIEXPORT jlong JNICALL Java_org_libvirt_Connect__1getVersion
   (JNIEnv *env, jobject obj, jlong VCP){
 	unsigned long hvVer=0;
-	int retval = virConnectGetVersion((virConnectPtr)VCP, &hvVer);
+	long retval = virConnectGetVersion((virConnectPtr)VCP, &hvVer);
 	return (jlong)(hvVer);
 };
 
@@ -146,31 +150,35 @@
 
 
 JNIEXPORT jlong JNICALL Java_org_libvirt_Connect__1open
-  (JNIEnv *env, jobject obj, jstring uri){
+  (JNIEnv *env, jobject obj, jstring j_uri){
 
 	virConnectPtr vc;
+	const char *uri=(*env)->GetStringUTFChars(env, j_uri, NULL);
 
 	//Initialize the libvirt VirtConn Object
-	vc=virConnectOpen((*env)->GetStringUTFChars(env, uri, NULL));
+	vc=virConnectOpen(uri);
+	(*env)->ReleaseStringUTFChars(env, j_uri, uri);
 	if(vc==NULL){
 		//We have a pending java exception, let's return
 		assert((*env)->ExceptionOccurred(env));
 		return (jlong)NULL;
 	}
 
-	//Initialized the error handler for this connection
+	//Initialize the error handler for this connection
 	virConnSetErrorFunc(vc, env, virErrorHandler);
 
 	return (jlong)vc;
 };
 
 JNIEXPORT jlong JNICALL Java_org_libvirt_Connect__1openReadOnly
-  (JNIEnv *env, jobject obj, jstring uri){
+  (JNIEnv *env, jobject obj, jstring j_uri){
 
 	virConnectPtr vc;
-
+	const char *uri=(*env)->GetStringUTFChars(env, j_uri, NULL);
+	
 	//Initialize the libvirt VirtConn Object
-	vc=virConnectOpenReadOnly((*env)->GetStringUTFChars(env, uri, NULL));
+	vc=virConnectOpenReadOnly(uri);
+	(*env)->ReleaseStringUTFChars(env, j_uri, uri);
 	if(vc==NULL){
 		//We have a pending java exception, let's return
 		assert((*env)->ExceptionOccurred(env));
@@ -184,10 +192,10 @@
 };
 
 JNIEXPORT jlong JNICALL Java_org_libvirt_Connect__1openAuth
-  (JNIEnv *env, jobject obj, jstring uri, jobject j_auth, jint flags){
+  (JNIEnv *env, jobject obj, jstring j_uri, jobject j_auth, jint flags){
 
 	virConnectPtr vc;
-	virError error;
+	const char *uri=(*env)->GetStringUTFChars(env, j_uri, NULL);
 
 	virConnectAuth *auth = malloc(sizeof(virConnectAuth));
 
@@ -222,8 +230,9 @@
 	cb_wrapper->env = env;
 	cb_wrapper->auth = j_auth;
 	auth->cbdata=cb_wrapper;
-
-	vc=virConnectOpenAuth((*env)->GetStringUTFChars(env, uri, NULL), auth, flags);
+	
+	vc=virConnectOpenAuth(uri, auth, flags);
+	(*env)->ReleaseStringUTFChars(env, j_uri, uri);
 	if (vc==NULL){
 		//We have a pending java exception, let's return
 		assert((*env)->ExceptionOccurred(env));
@@ -237,18 +246,27 @@
 }
 
 JNIEXPORT jlong JNICALL Java_org_libvirt_Connect__1virNetworkCreateXML
-  (JNIEnv *env, jobject obj, jlong VCP, jstring xmlDesc){
-	return (jlong)virNetworkCreateXML((virConnectPtr)VCP, (*env)->GetStringUTFChars(env, xmlDesc, NULL));
+  (JNIEnv *env, jobject obj, jlong VCP, jstring j_xmlDesc){
+	const char *xmlDesc=(*env)->GetStringUTFChars(env, j_xmlDesc, NULL);
+	jlong retval = (jlong)virNetworkCreateXML((virConnectPtr)VCP, xmlDesc);
+	(*env)->ReleaseStringUTFChars(env, j_xmlDesc, xmlDesc);
+	return retval;
 }
 
 JNIEXPORT jlong JNICALL Java_org_libvirt_Connect__1virNetworkDefineXML
-(JNIEnv *env, jobject obj, jlong VCP, jstring xmlDesc){
-	return (jlong)virNetworkDefineXML((virConnectPtr)VCP, (*env)->GetStringUTFChars(env, xmlDesc, NULL));
+(JNIEnv *env, jobject obj, jlong VCP, jstring j_xmlDesc){
+	const char *xmlDesc=(*env)->GetStringUTFChars(env, j_xmlDesc, NULL);
+	jlong retval = (jlong)virNetworkDefineXML((virConnectPtr)VCP, xmlDesc);
+	(*env)->ReleaseStringUTFChars(env, j_xmlDesc, xmlDesc);
+	return retval;
 }
 
 JNIEXPORT jlong JNICALL Java_org_libvirt_Connect__1virNetworkLookupByName
-  (JNIEnv *env, jobject obj, jlong VCP, jstring name){
-	return (jlong)virNetworkLookupByName((virConnectPtr)VCP, (*env)->GetStringUTFChars(env, name, NULL));
+  (JNIEnv *env, jobject obj, jlong VCP, jstring j_name){
+	const char *name=(*env)->GetStringUTFChars(env, j_name, NULL);
+	jlong retval = (jlong)virNetworkLookupByName((virConnectPtr)VCP, name);
+	(*env)->ReleaseStringUTFChars(env, j_name, name);
+	return retval;
 }
 
 JNIEXPORT jlong JNICALL Java_org_libvirt_Connect__1virNetworkLookupByUUID
@@ -264,8 +282,11 @@
 
 
 JNIEXPORT jlong JNICALL Java_org_libvirt_Connect__1virNetworkLookupByUUIDString
-  (JNIEnv *env, jobject obj, jlong VCP, jstring UUID){
-	return (jlong)virNetworkLookupByUUIDString((virConnectPtr)VCP, (*env)->GetStringUTFChars(env, UUID, NULL));
+  (JNIEnv *env, jobject obj, jlong VCP, jstring j_UUID){
+	const char *uuid=(*env)->GetStringUTFChars(env, j_UUID, NULL);
+	jlong retval =  (jlong)virNetworkLookupByUUIDString((virConnectPtr)VCP, uuid);
+	(*env)->ReleaseStringUTFChars(env, j_UUID, uuid);
+	return retval;
 }
 
 JNIEXPORT jobject JNICALL Java_org_libvirt_Connect__1virNodeInfo
@@ -342,8 +363,11 @@
 }
 
 JNIEXPORT jlong JNICALL Java_org_libvirt_Connect__1virDomainLookupByName
-  (JNIEnv *env, jobject obj, jlong VCP, jstring name){
-		return (jlong)virDomainLookupByName((virConnectPtr)VCP, (*env)->GetStringUTFChars(env, name, NULL));
+  (JNIEnv *env, jobject obj, jlong VCP, jstring j_name){
+	const char *name=(*env)->GetStringUTFChars(env, j_name, NULL);
+	jlong retval =  (jlong)virDomainLookupByName((virConnectPtr)VCP, name);
+	(*env)->ReleaseStringUTFChars(env, j_name, name);
+	return retval;
 }
 
 JNIEXPORT jlong JNICALL Java_org_libvirt_Connect__1virDomainLookupByUUID
@@ -358,8 +382,11 @@
 }
 
 JNIEXPORT jlong JNICALL Java_org_libvirt_Connect__1virDomainLookupByUUIDString
-  (JNIEnv *env, jobject obj, jlong VCP, jstring UUID){
-	return (jlong)virDomainLookupByUUIDString((virConnectPtr)VCP, (*env)->GetStringUTFChars(env, UUID, NULL));
+  (JNIEnv *env, jobject obj, jlong VCP, jstring j_UUID){
+	const char *UUID=(*env)->GetStringUTFChars(env, j_UUID, NULL);
+	jlong retval = (jlong)virDomainLookupByUUIDString((virConnectPtr)VCP, UUID);
+	(*env)->ReleaseStringUTFChars(env, j_UUID, UUID);
+	return retval;
 }
 
 JNIEXPORT jlong JNICALL Java_org_libvirt_Connect__1virGetLibVirVersion
@@ -376,26 +403,115 @@
 	type = (*env)->GetStringUTFChars(env, j_type, NULL);
 
 	virGetVersion(&libVer, type, &typeVer);
+	(*env)->ReleaseStringUTFChars(env, j_type, type);
 
 	return libVer;
 }
 
 JNIEXPORT jlong JNICALL Java_org_libvirt_Connect__1virDomainCreateLinux
-  (JNIEnv *env, jobject obj, jlong VCP, jstring xmlDesc, jint flags){
-	return(jlong)virDomainCreateLinux((virConnectPtr)VCP, (*env)->GetStringUTFChars(env, xmlDesc, NULL), flags);
+  (JNIEnv *env, jobject obj, jlong VCP, jstring j_xmlDesc, jint flags){
+	const char *xmlDesc=(*env)->GetStringUTFChars(env, j_xmlDesc, NULL);
+	jlong retval = (jlong)virDomainCreateLinux((virConnectPtr)VCP, xmlDesc, flags);
+	(*env)->ReleaseStringUTFChars(env, j_xmlDesc, xmlDesc);
+	return retval;	
 }
 
 JNIEXPORT jlong JNICALL Java_org_libvirt_Connect__1virDomainDefineXML
-  (JNIEnv *env, jobject obj, jlong VCP, jstring xmlDesc){
-	return(jlong)virDomainDefineXML((virConnectPtr)VCP, (*env)->GetStringUTFChars(env, xmlDesc, NULL));
+  (JNIEnv *env, jobject obj, jlong VCP, jstring j_xmlDesc){
+	const char *xmlDesc=(*env)->GetStringUTFChars(env, j_xmlDesc, NULL);
+	jlong retval = (jlong)virDomainDefineXML((virConnectPtr)VCP, xmlDesc);
+	(*env)->ReleaseStringUTFChars(env, j_xmlDesc, xmlDesc);
+	return retval;	
 }
 
 JNIEXPORT jint JNICALL Java_org_libvirt_Connect__1virDomainRestore
-  (JNIEnv *env, jobject obj, jlong VCP, jstring from){
-	return virDomainRestore((virConnectPtr)VCP, (char*)(*env)->GetStringUTFChars(env, from, NULL));
+  (JNIEnv *env, jobject obj, jlong VCP, jstring j_from){
+	const char *from=(*env)->GetStringUTFChars(env, j_from, NULL);
+	jint retval = (jint)virDomainRestore((virConnectPtr)VCP, from);
+	(*env)->ReleaseStringUTFChars(env, j_from, from);
+	return retval;	
 }
 
 JNIEXPORT jint JNICALL Java_org_libvirt_Connect__1setDom0Memory
   (JNIEnv *env, jobject obj, jlong memory){
 	return virDomainSetMemory(NULL, memory);
 }
+
+JNIEXPORT jint JNICALL Java_org_libvirt_Connect__1numOfDefinedStoragePools
+  (JNIEnv *env, jobject obj, jlong VCP){
+	return virConnectNumOfDefinedStoragePools((virConnectPtr)VCP);
+}
+
+JNIEXPORT jint JNICALL Java_org_libvirt_Connect__1numOfStoragePools
+  (JNIEnv *env, jobject obj, jlong VCP){
+	return virConnectNumOfStoragePools((virConnectPtr)VCP);
+}
+
+JNIEXPORT jobjectArray JNICALL Java_org_libvirt_Connect__1listDefinedStoragePools
+(JNIEnv *env, jobject obj, jlong VCP){
+	int maxnames;
+	char **names;
+	int c;
+	jobjectArray j_names=NULL;
+	if((maxnames = virConnectNumOfDefinedStoragePools((virConnectPtr)VCP))<0)
+		return NULL;
+	names= (char**)calloc(maxnames, sizeof(char*));
+	if(virConnectListDefinedStoragePools((virConnectPtr)VCP, names, maxnames)>=0){
+		j_names= (jobjectArray)(*env)->NewObjectArray(env, maxnames,
+			(*env)->FindClass(env,"java/lang/String"),
+			(*env)->NewStringUTF(env,""));
+		for(c=0; c<maxnames; c++){
+			(*env)->SetObjectArrayElement(env, j_names, c, (*env)->NewStringUTF(env, names[c]));
+		}
+	}
+	free(names);
+
+	return j_names;
+}
+
+JNIEXPORT jobjectArray JNICALL Java_org_libvirt_Connect__1listStoragePools
+(JNIEnv *env, jobject obj, jlong VCP){
+	int maxnames;
+	char **names;
+	int c;
+	jobjectArray j_names=NULL;
+	if((maxnames = virConnectNumOfStoragePools((virConnectPtr)VCP))<0)
+		return NULL;
+	names= (char**)calloc(maxnames, sizeof(char*));
+	if(virConnectListStoragePools((virConnectPtr)VCP, names, maxnames)>=0){
+		j_names= (jobjectArray)(*env)->NewObjectArray(env, maxnames,
+			(*env)->FindClass(env,"java/lang/String"),
+			(*env)->NewStringUTF(env,""));
+		for(c=0; c<maxnames; c++){
+			(*env)->SetObjectArrayElement(env, j_names, c, (*env)->NewStringUTF(env, names[c]));
+		}
+	}
+	free(names);
+
+	return j_names;
+}
+
+JNIEXPORT jlong JNICALL Java_org_libvirt_Connect__1virStoragePoolCreateXML
+(JNIEnv *env, jobject obj, jlong VCP, jstring j_xmlDesc, jint flags){
+	const char *xmlDesc=(*env)->GetStringUTFChars(env, j_xmlDesc, NULL);
+	jlong retval = (jlong)virStoragePoolCreateXML((virConnectPtr)VCP, xmlDesc, flags);
+	(*env)->ReleaseStringUTFChars(env, j_xmlDesc, xmlDesc);
+	return retval;
+}
+
+JNIEXPORT jlong JNICALL Java_org_libvirt_Connect__1virStoragePoolDefineXML
+(JNIEnv *env, jobject obj, jlong VCP, jstring j_xmlDesc, jint flags){
+	const char *xmlDesc=(*env)->GetStringUTFChars(env, j_xmlDesc, NULL);
+	jlong retval = (jlong)virStoragePoolDefineXML((virConnectPtr)VCP, xmlDesc, flags);
+	(*env)->ReleaseStringUTFChars(env, j_xmlDesc, xmlDesc);
+	return retval;
+}
+
+JNIEXPORT jlong JNICALL Java_org_libvirt_Connect__1virStoragePoolLookupByName
+(JNIEnv *env, jobject obj, jlong VCP, jstring j_name){
+	const char *name=(*env)->GetStringUTFChars(env, j_name, NULL);
+	jlong retval = (jlong)virStoragePoolLookupByName((virConnectPtr)VCP, name);
+	(*env)->ReleaseStringUTFChars(env, j_name, name);
+	return retval;	
+}
+
Index: src/jni/Makefile.am
===================================================================
RCS file: /data/cvs/libvirt-java/src/jni/Makefile.am,v
retrieving revision 1.5
diff -u -r1.5 Makefile.am
--- src/jni/Makefile.am	18 Jul 2008 14:37:21 -0000	1.5
+++ src/jni/Makefile.am	2 Aug 2008 15:21:11 -0000
@@ -4,7 +4,13 @@
   org_libvirt_Domain.h \
   org_libvirt_Domain_CreateFlags.h \
   org_libvirt_Domain_MigrateFlags.h \
-  org_libvirt_Domain_XMLFlags.h
+  org_libvirt_Domain_XMLFlags.h \
+  org_libvirt_StoragePool_BuildFlags.h \
+  org_libvirt_StoragePool_DeleteFlags.h \
+  org_libvirt_StoragePool.h \
+  org_libvirt_StorageVol_Type.h \
+  org_libvirt_StorageVol_DeleteFlags.h \
+  org_libvirt_StorageVol.h
 
 BUILT_SOURCES = $(GENERATED)
 
@@ -18,12 +24,22 @@
 
 org_libvirt_Domain.h org_libvirt_Domain_CreateFlags.h org_libvirt_Domain_MigrateFlags.h org_libvirt_Domain_XMLFlags.h : $(JAVA_CLASS_ROOT)/org/libvirt/Domain.class
 	$(JAVAH) -classpath $(JAVA_CLASS_ROOT) org.libvirt.Domain
+	
+org_libvirt_StoragePool.h org_libvirt_StoragePool_BuildFlags.h org_libvirt_StoragePool_DeleteFlags.h : $(JAVA_CLASS_ROOT)/org/libvirt/StoragePool.class
+	$(JAVAH) -classpath $(JAVA_CLASS_ROOT) org.libvirt.StoragePool
+	
+org_libvirt_StorageVol.h org_libvirt_StorageVol_Type.h org_libvirt_StorageVol_DeleteFlags.h : $(JAVA_CLASS_ROOT)/org/libvirt/StorageVol.class
+	$(JAVAH) -classpath $(JAVA_CLASS_ROOT) org.libvirt.StorageVol
 
 lib_LTLIBRARIES = libvirt_jni.la
 libvirt_jni_la_SOURCES = \
   org_libvirt_Network.c \
   org_libvirt_Connect.c \
   org_libvirt_Domain.c \
+  org_libvirt_StoragePool.c \
+  org_libvirt_StorageVol.c \
+  generic.c \
+  generic.h \
   ErrorHandler.c \
   ErrorHandler.h \
   ConnectAuthCallbackBridge.c \
Index: libvirt-java.spec.in
===================================================================
RCS file: /data/cvs/libvirt-java/libvirt-java.spec.in,v
retrieving revision 1.9
diff -u -r1.9 libvirt-java.spec.in
--- libvirt-java.spec.in	18 Jul 2008 14:37:21 -0000	1.9
+++ libvirt-java.spec.in	2 Aug 2008 15:21:10 -0000
@@ -1,7 +1,7 @@
 Summary:	Java bindings for the libvirt virtualization API
 Name:		libvirt-java
 Version:	@VERSION@
-Release:	1%{?dist}
+Release:	2%{?dist}
 License:	LGPLv2+
 Group:		Development/Libraries
 Source:		http://libvirt.org/sources/java/libvirt-java-%{version}.tar.gz
Index: src/jni/generic.c
===================================================================
RCS file: src/jni/generic.c
diff -N src/jni/generic.c
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ src/jni/generic.c	1 Jan 1970 00:00:00 -0000
@@ -0,0 +1,128 @@
+#include "generic.h"
+#include <jni.h>
+#include <stdlib.h>
+
+jint generic__virObj__int
+(JNIEnv *env, jobject obj, jlong virObj1, int (*virFunc1)(void*) ){
+	return (jint)virFunc1((void*)virObj1);
+}
+
+jint generic__virObj_int__int
+  (JNIEnv *env, jobject obj, jlong virObj1, jint arg1, int (*virFunc1)(void*, int)){
+	return (jint)virFunc1((void*)virObj1, arg1);
+}
+
+jstring generic__virObj__conststring
+  (JNIEnv *env, jobject obj, jlong virObj1, const char* (*virFunc1)(void*)){
+	jstring j_retstring=NULL;
+	const char *retstring;
+	if((retstring = virFunc1((void*)virObj1))){
+		j_retstring = (*env)->NewStringUTF(env, retstring);
+	} 
+	return j_retstring;
+}
+
+jstring generic__virObj__string
+  (JNIEnv *env, jobject obj, jlong virObj1, char* (*virFunc1)(void*)){
+	jstring j_retstring=NULL;
+	char *retstring;
+	if((retstring = virFunc1((void*)virObj1))){
+		j_retstring = (*env)->NewStringUTF(env, retstring);
+		free(retstring);
+	} 
+	return j_retstring;
+}
+
+jstring generic__virObj_int__string
+  (JNIEnv *env, jobject obj, jlong virObj, jint arg1, char* (*virFunc1)(void*, int)){
+	jstring j_retstring;
+	char* retstring = NULL;
+	if((retstring = virFunc1((void*)virObj, arg1))){
+		j_retstring = (*env)->NewStringUTF(env, retstring);
+		free(retstring);
+	}
+	return j_retstring;
+}
+
+jboolean generic_getAutostart
+  (JNIEnv *env, jobject obj, jlong virObj, int (*VirFunc1)(void*, int*)){
+	int autostart=0;
+	VirFunc1((virStoragePoolPtr)virObj, &autostart);
+	return (jboolean)autostart;
+}
+
+jintArray generic_getUUID
+  (JNIEnv *env, jobject obj, jlong virObj1, int	(*virFunc1)(void*, unsigned char*)){
+	unsigned char uuid[VIR_UUID_BUFLEN];
+	jintArray j_uuid;
+	int c;
+	int uuidbyte;
+
+	if(virFunc1((void*)virObj1, uuid)<0)
+		return NULL;
+	//unpack UUID
+	j_uuid=(*env)->NewIntArray(env, VIR_UUID_BUFLEN);
+	for(c=0; c<VIR_UUID_BUFLEN; c++){
+			uuidbyte=uuid[c];
+			(*env)->SetIntArrayRegion(env, j_uuid, c, 1, &uuidbyte);
+	}
+	return j_uuid;
+}
+
+jstring generic_getUUIDString
+  (JNIEnv *env, jobject obj, jlong virObj, int (*virFunc1)(void*, char*)){
+	char uuidString[VIR_UUID_STRING_BUFLEN];
+	virFunc1((void*)virObj, uuidString);
+	return (*env)->NewStringUTF(env, uuidString);
+}
+
+JNIEXPORT jobjectArray JNICALL generic_list_stringarray
+  (JNIEnv *env, jobject obj, jlong virObj, int (*virFunc1)(void*, char ** const, int), int (*virFunc2)(void*)){
+	int maxnames;
+	char **names;
+	int c;
+	jobjectArray j_names=NULL;
+	if((maxnames = virFunc2((void*)virObj))<0)
+		return NULL;
+	names= (char**)calloc(maxnames, sizeof(char*));
+	if(virFunc1((void*)virObj, names, maxnames)>=0){
+		j_names= (jobjectArray)(*env)->NewObjectArray(env, maxnames,
+			(*env)->FindClass(env,"java/lang/String"),
+			(*env)->NewStringUTF(env,""));
+		for(c=0; c<maxnames; c++){
+			(*env)->SetObjectArrayElement(env, j_names, c, (*env)->NewStringUTF(env, names[c]));
+		}
+	}
+	free(names);
+
+	return j_names;
+}
+
+JNIEXPORT jlong JNICALL generic_lookupBy_string
+  (JNIEnv *env, jobject obj, jlong virObj, jstring j_stringid, void* (*virFunc1)(void*, const char *)){
+	const char *stringid=(*env)->GetStringUTFChars(env, j_stringid, NULL);
+	jlong retval = (jlong)virFunc1((void*)virObj, stringid);
+	(*env)->ReleaseStringUTFChars(env, j_stringid, stringid);
+	return retval;
+}
+
+JNIEXPORT jlong JNICALL generic_lookupBy_none
+  (JNIEnv *env, jobject obj, jlong virObj, void* (*virFunc1)(void*)){
+	return (jlong)virFunc1((void*)virObj);
+}
+
+JNIEXPORT jlong JNICALL generic_CreateDefineXML
+  (JNIEnv *env, jobject obj, jlong virObj, jstring j_xmlDesc, void*	(*virFunc1)	(void*, const char *)){
+	const char *xmlDesc=(*env)->GetStringUTFChars(env, j_xmlDesc, NULL);
+	jlong retval = (jlong)virFunc1((void*)virObj, xmlDesc);
+	(*env)->ReleaseStringUTFChars(env, j_xmlDesc, xmlDesc);
+	return retval;
+}
+
+JNIEXPORT jlong JNICALL generic_CreateDefineXML_with_flags
+  (JNIEnv *env, jobject obj, jlong virObj, jstring j_xmlDesc, jint flags, void*	(*virFunc1)	(void*, const char *, unsigned int)){
+	const char *xmlDesc=(*env)->GetStringUTFChars(env, j_xmlDesc, NULL);
+	jlong retval = (jlong)virFunc1((void*)virObj, xmlDesc, flags);
+	(*env)->ReleaseStringUTFChars(env, j_xmlDesc, xmlDesc);
+	return retval;
+}
Index: src/jni/org_libvirt_StoragePool.c
===================================================================
RCS file: src/jni/org_libvirt_StoragePool.c
diff -N src/jni/org_libvirt_StoragePool.c
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ src/jni/org_libvirt_StoragePool.c	1 Jan 1970 00:00:00 -0000
@@ -0,0 +1,117 @@
+#include <libvirt/libvirt.h>
+#include "org_libvirt_StoragePool.h"
+#include "generic.h"
+
+
+JNIEXPORT jint JNICALL Java_org_libvirt_StoragePool__1build
+  (JNIEnv *env, jobject obj, jlong VSPP, jint flags){
+	return generic__virObj_int__int(env, obj, VSPP, flags, (int (*)(void*, int))&virStoragePoolBuild);
+}
+
+JNIEXPORT jint JNICALL Java_org_libvirt_StoragePool__1create
+  (JNIEnv *env, jobject obj, jlong VSPP, jint flags){
+	return generic__virObj_int__int(env, obj, VSPP, flags, (int (*)(void*, int))&virStoragePoolCreate);
+}
+
+JNIEXPORT jint JNICALL Java_org_libvirt_StoragePool__1delete
+  (JNIEnv *env, jobject obj, jlong VSPP, jint flags){
+	return generic__virObj_int__int(env, obj, VSPP, flags, (int (*)(void*, int))&virStoragePoolDelete);
+}
+
+JNIEXPORT jint JNICALL Java_org_libvirt_StoragePool__1destroy
+  (JNIEnv *env, jobject obj, jlong VSPP){
+	return generic__virObj__int(env, obj, VSPP, (int (*)(void*))&virStoragePoolDelete);
+}
+
+JNIEXPORT jint JNICALL Java_org_libvirt_StoragePool__1free
+  (JNIEnv *env, jobject obj, jlong VSPP){
+	return generic__virObj__int(env, obj, VSPP, (int (*)(void*))&virStoragePoolFree);
+}
+
+JNIEXPORT jboolean JNICALL Java_org_libvirt_StoragePool__1getAutostart
+  (JNIEnv *env, jobject obj, jlong VSPP){
+	return generic_getAutostart(env, obj, VSPP, (int (*)(void*, int*))&virStoragePoolGetAutostart);
+}
+
+JNIEXPORT jobject JNICALL Java_org_libvirt_StoragePool__1getInfo
+  (JNIEnv *env, jobject obj, jlong VSPP){
+
+	virStoragePoolInfo storagePoolInfo;
+
+	jobject j_info;
+
+	//Get the data
+	if(virStoragePoolGetInfo((virStoragePoolPtr)VSPP, &storagePoolInfo)<0)
+		return NULL;
+
+	//get the field Ids of info
+	jclass j_storagePoolInfo_cls = (*env)->FindClass(env,"org/libvirt/StoragePoolInfo");
+	jmethodID j_storagePoolInfo_constructor = (*env)->GetMethodID(env, j_storagePoolInfo_cls, "<init>", "(IJJJ)V");
+	
+	//Long live encapsulation
+	j_info=(*env)->NewObject(env,
+					j_storagePoolInfo_cls,
+					j_storagePoolInfo_constructor,
+					storagePoolInfo.state,
+					storagePoolInfo.capacity,
+					storagePoolInfo.allocation,
+					storagePoolInfo.available);	
+
+	return j_info;
+}
+
+JNIEXPORT jstring JNICALL Java_org_libvirt_StoragePool__1getName
+  (JNIEnv *env, jobject obj, jlong VSPP){
+	return generic__virObj__conststring(env, obj, VSPP, (const char* (*)(void*))&virStoragePoolGetName);
+}
+
+JNIEXPORT jintArray JNICALL Java_org_libvirt_StoragePool__1getUUID
+  (JNIEnv *env, jobject obj, jlong VSPP){
+	return generic_getUUID(env, obj, VSPP, (int (*)(void*, unsigned char*))&virStoragePoolGetUUID);
+}
+
+JNIEXPORT jstring JNICALL Java_org_libvirt_StoragePool__1getUUIDString
+  (JNIEnv *env, jobject obj, jlong VSPP){
+	return generic_getUUIDString(env, obj, VSPP, (int (*)(void*, char*))&virStoragePoolGetUUIDString);
+}
+
+JNIEXPORT jstring JNICALL Java_org_libvirt_StoragePool__1getXMLDesc
+  (JNIEnv *env, jobject obj, jlong VSPP, jint flags){
+	return generic__virObj_int__string(env, obj, VSPP, flags, (char* (*)(void*, int))&virStoragePoolGetXMLDesc);
+}
+
+JNIEXPORT jobjectArray JNICALL Java_org_libvirt_StoragePool__1listVolumes
+  (JNIEnv *env, jobject obj, jlong VSPP){
+	return generic_list_stringarray(env, obj, VSPP, (int (*)(void*, char ** const, int))&virStoragePoolListVolumes, (int (*)(void*))&virStoragePoolNumOfVolumes);
+}
+
+JNIEXPORT jint JNICALL Java_org_libvirt_StoragePool__1numOfVolumes
+  (JNIEnv *env, jobject obj, jlong VSPP){
+	return generic__virObj__int(env, obj, VSPP, (int (*)(void*))&virStoragePoolNumOfVolumes);
+}
+
+JNIEXPORT void JNICALL Java_org_libvirt_StoragePool__1refresh
+  (JNIEnv *env, jobject obj, jlong VSPP, jint flags){
+	generic__virObj_int__int(env, obj, VSPP, flags, (int (*)(void*, int))&virStoragePoolRefresh);
+}
+
+JNIEXPORT void JNICALL Java_org_libvirt_StoragePool__1setAutostart
+  (JNIEnv *env, jobject obj, jlong VSPP, jint flags){
+	generic__virObj_int__int(env, obj, VSPP, flags, (int (*)(void*, int))&virStoragePoolSetAutostart);
+}
+
+JNIEXPORT void JNICALL Java_org_libvirt_StoragePool__1undefine
+(JNIEnv *env, jobject obj, jlong VSPP){
+	generic__virObj__int(env, obj, VSPP, (int (*)(void*))&virStoragePoolUndefine);
+}
+
+JNIEXPORT jlong JNICALL Java_org_libvirt_StoragePool__1storageVolLookupByName
+  (JNIEnv *env, jobject obj, jlong VSPP, jstring name){
+	return generic_lookupBy_string(env, obj, VSPP, name, (void* (*)(void*, const char *))&virStorageVolLookupByName);
+}
+
+JNIEXPORT jlong JNICALL Java_org_libvirt_StoragePool__1storageVolCreateXML
+  (JNIEnv *env, jobject obj, jlong VSPP, jstring xmlDesc, jint flags){
+	return generic_CreateDefineXML_with_flags(env, obj, VSPP, xmlDesc, flags, (void* (*)(void*, const char *, unsigned int))&virStorageVolCreateXML);
+}
+
Index: src/org/libvirt/StorageVolInfo.java
===================================================================
RCS file: src/org/libvirt/StorageVolInfo.java
diff -N src/org/libvirt/StorageVolInfo.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ src/org/libvirt/StorageVolInfo.java	1 Jan 1970 00:00:00 -0000
@@ -0,0 +1,53 @@
+package org.libvirt;
+
+public class StorageVolInfo {
+	
+	/**
+	 * The type of the Volume
+	 */
+	public VirStorageVolType type;
+	/**
+	 * Logical size bytes
+	 */
+	public long	capacity;
+	/**
+	 * Current allocation bytes
+	 */
+	public long	allocation;
+	
+	public static enum VirStorageVolType{
+		/**
+		 * Regular file based volumes
+		 */
+		VIR_STORAGE_VOL_FILE, 
+		/**
+		 * Block based volumes
+		 */
+		VIR_STORAGE_VOL_BLOCK, 
+	}
+	
+	/**
+	 * This is meant to be called from the JNI side, as a convenience constructor
+	 * 
+	 * @param type the type, as defined by libvirt
+	 * @param capacity
+	 * @param allocation
+	 */
+	StorageVolInfo(int type, long capacity, long allocation){
+		switch(type){
+			case 0: this.type=VirStorageVolType.VIR_STORAGE_VOL_FILE; break;
+			case 1: this.type=VirStorageVolType.VIR_STORAGE_VOL_BLOCK; break;
+			default: assert(false);
+		}
+		this.capacity = capacity;
+		this.allocation = allocation;
+	}	
+	
+	public String toString(){
+		StringBuffer result = new StringBuffer("");
+		result.append("type:" + type + "\n");
+		result.append("capacity:" + capacity + "\n");
+		result.append("allocation:" + allocation + "\n");
+		return result.toString();
+	}
+}
Index: src/org/libvirt/StorageVol.java
===================================================================
RCS file: src/org/libvirt/StorageVol.java
diff -N src/org/libvirt/StorageVol.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ src/org/libvirt/StorageVol.java	1 Jan 1970 00:00:00 -0000
@@ -0,0 +1,158 @@
+package org.libvirt;
+
+public class StorageVol {
+	
+	static final class DeleteFlags{
+		/**
+		 * Delete metadata only (fast)
+		 */
+		static final int VIR_STORAGE_POOL_DELETE_NORMAL	 = 	0;
+		/**
+		 * Clear all data to zeros (slow)
+		 */
+		static final int VIR_STORAGE_POOL_DELETE_ZEROED	= 	1;
+	}
+	
+	public static enum Type {
+		/**
+		 * Regular file based volumes
+		 */
+		VIR_STORAGE_VOL_FILE,
+		/**
+		 * Block based volumes
+		 */
+		VIR_STORAGE_VOL_BLOCK
+	}
+
+	/**
+	 * the native virStorageVolPtr.
+	 */
+	private long  VSVP;
+	
+	/**
+	 * The VirConnect Object that represents the Hypervisor of this Domain
+	 */
+	private Connect virConnect;
+	
+	
+	/**
+	 * Constructs a VirStorageVol object from a known native virStoragePoolPtr, and a VirConnect object.
+	 * For use when native libvirt returns a virStorageVolPtr, i.e. error handling.
+	 * 
+	 * @param virConnect the Domain's hypervisor
+	 * @param VSVP the native virStorageVolPtr
+	 */
+	StorageVol(Connect virConnect, long VSVP){
+		this.virConnect = virConnect;
+		this.VSVP = VSVP;
+	}
+	
+	/**
+	 * Fetch a storage pool which contains this volume
+	 * 
+	 * @return StoragePool object, 
+	 * @throws LibvirtException
+	 */
+	public StoragePool storagePoolLookupByVolume()
+	throws LibvirtException {
+		return new StoragePool(virConnect, _storagePoolLookupByVolume(VSVP));
+	}
+
+	private native long _storagePoolLookupByVolume(long VSVP)
+	throws LibvirtException;
+
+	/**
+	 * Delete the storage volume from the pool
+	 * 
+	 * @param flags future flags, use 0 for now
+	 * @throws LibvirtException
+	 */
+	public void delete(int flags) throws LibvirtException{
+		_delete(VSVP, flags);
+	}
+	
+	private native int _delete(long VSVP, int flags) throws LibvirtException;
+	
+	/**
+	 * Release the storage volume handle. The underlying storage volume contains to exist
+	 * 
+	 * @throws LibvirtException
+	 */
+	public void free() throws LibvirtException{
+		_free(VSVP);
+	}
+	
+	private native int _free(long VSVP) throws LibvirtException;
+	
+	/**
+	 * Provides the connection object associated with a storage volume. The reference counter on the connection is not increased by this call.
+	 * 
+	 * @return the Connect object
+	 */
+	public Connect getConnect(){
+		return virConnect;
+	}
+	
+	/**
+	 * Fetches volatile information about the storage volume such as its current allocation
+	 * 
+	 * @return StorageVolInfo object
+	 * @throws LibvirtException
+	 */
+	public StorageVolInfo getInfo() throws LibvirtException{
+		return _getInfo(VSVP);
+	}
+
+	private native StorageVolInfo _getInfo(long VSVP) throws LibvirtException;
+
+	/**
+	 * Fetch the storage volume key. This is globally unique, so the same volume will have the same key no matter what host it is accessed from
+	 * 
+	 * @return the key
+	 * @throws LibvirtException
+	 */
+	public String getKey() throws LibvirtException{
+		return _getKey(VSVP);
+	}
+
+	private native String _getKey(long VSVP) throws LibvirtException;
+	
+	/**
+	 * Fetch the storage volume name. This is unique within the scope of a pool
+	 * 
+	 * @return the name
+	 * @throws LibvirtException
+	 */
+	public String getName() throws LibvirtException{
+		return _getName(VSVP);
+	}
+
+	private native String _getName(long VSVP) throws LibvirtException;
+	
+	/**
+	 * Fetch the storage volume path. 
+	 * Depending on the pool configuration this is either persistent across hosts, or dynamically assigned at pool startup. 
+	 * Consult pool documentation for information on getting the persistent naming
+	 * 
+	 * @return 
+	 * @throws LibvirtException
+	 */
+	public String getPath() throws LibvirtException{
+		return _getPath(VSVP);
+	}
+
+	private native String _getPath(long VSVP) throws LibvirtException;
+	
+	/**
+	 * Fetch an XML document describing all aspects of this storage volume
+	 * 
+	 * @param flags flags for XML generation (unused, pass 0)
+	 * @return the XML document
+	 * @throws LibvirtException
+	 */
+	public String getXMLDesc(int flags) throws LibvirtException{
+		return _getXMLDesc(VSVP, flags);
+	}
+	
+	private native String _getXMLDesc(long VSVP, int flags) throws LibvirtException;
+}
Index: src/org/libvirt/StoragePoolInfo.java
===================================================================
RCS file: src/org/libvirt/StoragePoolInfo.java
diff -N src/org/libvirt/StoragePoolInfo.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ src/org/libvirt/StoragePoolInfo.java	1 Jan 1970 00:00:00 -0000
@@ -0,0 +1,73 @@
+package org.libvirt;
+
+public class StoragePoolInfo {
+	
+	/**
+	 * the running state
+	 */
+	public StoragePoolState state;
+	
+	/**
+	 * Logical size bytes
+	 */
+	public long capacity;
+	
+	/**
+	 * Current allocation bytes
+	 */
+	public long allocation;
+	
+	/**
+	 * Remaining free space bytes
+	 */
+	public long available;
+	
+	public static enum StoragePoolState {
+		/**
+		 * Not running
+		 */
+		VIR_STORAGE_POOL_INACTIVE, 
+		/**
+		 * Initializing pool, not available
+		 */
+		VIR_STORAGE_POOL_BUILDING, 
+		/**
+		 * Running normally
+		 */
+		VIR_STORAGE_POOL_RUNNING, 
+		/**
+		 * Running degraded
+		 */
+		VIR_STORAGE_POOL_DEGRADED, 
+	}
+	
+	/**
+	 * This is meant to be called from the JNI side, as a convenience constructor
+	 * 
+	 * @param state the state, as defined by libvirt
+	 * @param capacity 
+	 * @param allocation
+	 * @param available
+	 */
+	StoragePoolInfo(int state, long capacity, long allocation, long available){
+		switch(state){
+			case 0: this.state=StoragePoolState.VIR_STORAGE_POOL_INACTIVE; break;
+			case 1: this.state=StoragePoolState.VIR_STORAGE_POOL_BUILDING; break;
+			case 2: this.state=StoragePoolState.VIR_STORAGE_POOL_RUNNING; break;
+			case 3: this.state=StoragePoolState.VIR_STORAGE_POOL_DEGRADED; break;
+			default: assert(false);
+		}
+		this.capacity = capacity;
+		this.allocation = allocation;
+		this.available = available;
+	}
+	
+	public String toString(){
+		StringBuffer result = new StringBuffer("");
+		result.append("state:" + state + "\n");
+		result.append("capacity:" + capacity + "\n");
+		result.append("allocation:" + allocation + "\n");
+		result.append("available:" + available + "\n");
+		return result.toString();
+	}
+}
Index: src/org/libvirt/StoragePool.java
===================================================================
RCS file: src/org/libvirt/StoragePool.java
diff -N src/org/libvirt/StoragePool.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ src/org/libvirt/StoragePool.java	1 Jan 1970 00:00:00 -0000
@@ -0,0 +1,286 @@
+package org.libvirt;
+
+public class StoragePool {
+
+	static final class BuildFlags{
+		/**
+		 * Regular build from scratch
+		 */
+		static final int VIR_STORAGE_POOL_BUILD_NEW	 = 	0;
+		/**
+		 * Repair / reinitialize
+		 */
+		static final int VIR_STORAGE_POOL_BUILD_REPAIR	= 	1; 
+		/**
+		 * Extend existing pool
+		 */
+		static final int VIR_STORAGE_POOL_BUILD_RESIZE	= 	2;
+	}
+	
+	static final class DeleteFlags{
+		/**
+		 * Delete metadata only (fast)
+		 */
+		static final int VIR_STORAGE_POOL_DELETE_NORMAL	 = 	0;
+		/**
+		 * Clear all data to zeros (slow)
+		 */
+		static final int VIR_STORAGE_POOL_DELETE_ZEROED	= 	1;
+	}
+	
+	/**
+	 * the native virStoragePoolPtr.
+	 */
+	private long  VSPP;
+	
+	/**
+	 * The VirConnect Object that represents the Hypervisor of this Domain
+	 */
+	private Connect virConnect;
+	
+	
+	/**
+	 * Constructs a VirStoragePool object from a known native virStoragePoolPtr, and a VirConnect object.
+	 * For use when native libvirt returns a virStoragePoolPtr, i.e. error handling.
+	 * 
+	 * @param virConnect the Domain's hypervisor
+	 * @param VSPP the native virStoragePoolPtr
+	 */
+	StoragePool(Connect virConnect, long VSPP){
+		this.virConnect = virConnect;
+		this.VSPP = VSPP;
+	}
+	
+	/**
+	 * Build the underlying storage pool
+	 * 
+	 * @param flags future flags, use 0 for now
+	 */
+	public void build(int flags) throws LibvirtException{
+		_build(VSPP, flags);
+	}
+	
+	private native int _build(long VSPP, int flags) throws LibvirtException;
+	
+	/**
+	 * Starts this inactive storage pool
+	 * 
+	 * @param flags future flags, use 0 for now
+	 */
+	public void create(int flags) throws LibvirtException{
+		_create(VSPP, flags);
+	}
+	
+	private native int _create(long VSPP, int flags) throws LibvirtException;
+	
+	/**
+	 * Delete the underlying pool resources. This is a non-recoverable operation. 
+	 * The virStoragePool object itself is not free'd.
+	 * 
+	 * @param flags flags for obliteration process
+	 */
+	public void delete(int flags) throws LibvirtException{
+		_delete(VSPP, flags);
+	}
+	
+	private native int _delete(long VSPP, int flags) throws LibvirtException;
+	
+	/**
+	 * Destroy an active storage pool. 
+	 * This will deactivate the pool on the host, but keep any persistent config associated with it. 
+	 * If it has a persistent config it can later be restarted with virStoragePoolCreate(). 
+	 * This does not free the associated virStoragePoolPtr object.
+	 */
+	public void destroy() throws LibvirtException{
+		_destroy(VSPP);
+	}
+	
+	private native int _destroy(long VSPP) throws LibvirtException;
+	
+	/**
+	 * Free a storage pool object, releasing all memory associated with it. 
+	 * Does not change the state of the pool on the host.
+	 */
+	public void free() throws LibvirtException{
+		_free(VSPP);
+	}
+	
+	private native int _free(long VSPP) throws LibvirtException;
+	
+	
+	/**
+	 * Fetches the value of the autostart flag, which determines whether the pool is automatically started at boot time
+	 *
+	 * @return the result
+	 * @throws LibvirtException
+	 */
+	public boolean getAutostart() throws LibvirtException{
+		return _getAutostart(VSPP);
+	}
+
+	private native boolean _getAutostart(long VSPP) throws LibvirtException;
+	
+	/**
+	 * Provides the connection pointer associated with a storage pool.
+	 *
+	 * @return the Connect object
+	 */
+	public Connect getConnect(){
+		return virConnect;
+	}
+	/**
+	 * Get volatile information about the storage pool such as free space / usage summary
+	 *
+	 * @return a StoragePoolInfo object describing this storage pool
+	 * @throws LibvirtException
+	 */
+	public StoragePoolInfo getInfo() throws LibvirtException{
+		return _getInfo(VSPP);
+	}
+
+	private native StoragePoolInfo _getInfo(long VSPP) throws LibvirtException;
+
+	/**
+	 * Fetch the locally unique name of the storage pool
+	 *
+	 * @return the name
+	 * @throws LibvirtException
+	 */
+	public String getName() throws LibvirtException{
+		return _getName(VSPP);
+	}
+
+	private native String _getName(long VSPP) throws LibvirtException;
+	
+	/**
+	 * Fetch the globally unique ID of this storage pool
+	 * 
+	 * @return the UUID as an unpacked int array
+	 * @throws LibvirtException
+	 */
+	public int[] getUUID() throws LibvirtException{
+		return _getUUID(VSPP);
+	}
+	
+	private native int[] _getUUID(long VSPP) throws LibvirtException;
+	
+
+	/**
+	 * Fetch the globally unique ID of the storage pool as a string
+	 * 
+	 * @return the UUID in canonical String format
+	 * @throws LibvirtException
+	 */
+	public String getUUIDString() throws LibvirtException{
+		return _getUUIDString(VSPP);
+	}
+
+	private native String _getUUIDString(long VSPP) throws LibvirtException;
+	
+	/**
+	 * Fetch an XML document describing all aspects of the storage pool. 
+	 * This is suitable for later feeding back into the virStoragePoolCreateXML method.
+	 * 
+	 * @param flags flags for XML format options (set of virDomainXMLFlags)
+	 * @return a XML document
+	 *-java @throws LibvirtException
+	 */
+	public String getXMLDesc(int flags) throws LibvirtException{
+		return _getXMLDesc(VSPP, flags);
+	}
+	
+	private native String _getXMLDesc(long VSPP, int flags) throws LibvirtException;
+	
+	/**
+	 * Fetch list of storage volume names
+	 *
+	 * @return an Array of Strings that contains the names of the storage volumes
+	 * @throws LibvirtException
+	 */
+	public String[] listVolumes() throws LibvirtException {
+		return _listVolumes(VSPP);
+	}
+
+	private native String[] _listVolumes(long VSPP)
+	throws LibvirtException;
+
+	/**
+	 * Fetch the number of storage volumes within a pool
+	 *
+	 * @return the number of storage pools
+	 * @throws LibvirtException
+	 */
+	public int numOfVolumes() throws LibvirtException {
+		return _numOfVolumes(VSPP);
+	}
+
+	private native int _numOfVolumes(long VSPP) throws LibvirtException;
+
+	/**
+	 * Request that the pool refresh its list of volumes. 
+	 * This may involve communicating with a remote server, and/or initializing new devices at the OS layer
+	 *
+	 * @param flags flags to control refresh behaviour (currently unused, use 0)
+	 * @throws LibvirtException
+	 */
+	public void refresh(int flags) throws LibvirtException {
+		_refresh(VSPP, flags);
+	}
+
+	private native void _refresh(long VSPP, int flags) throws LibvirtException;
+
+	/**
+	 * Sets the autostart flag
+	 *
+	 * @param autostart	new flag setting
+	 * @throws LibvirtException
+	 */
+	public void setAutostart(int autostart) throws LibvirtException {
+		_setAutostart(VSPP, autostart);
+	}
+
+	private native void _setAutostart(long VSPP, int autostart) throws LibvirtException;
+
+	/**
+	 * Undefine an inactive storage pool
+	 *
+	 * @throws LibvirtException
+	 */
+	public void undefine() throws LibvirtException {
+		_undefine(VSPP);
+	}
+
+	private native void _undefine(long VSPP) throws LibvirtException;
+
+	/**
+	 * Fetch an object representing to a storage volume based on its name within a pool
+	 *
+	 * @param name name of storage volume
+	 * @return The StorageVol object found
+	 * @throws LibvirtException
+	 */
+	public StorageVol storageVolLookupByName(String name)
+	throws LibvirtException {
+		return new StorageVol(virConnect, _storageVolLookupByName(VSPP, name));
+	}
+
+	private native long _storageVolLookupByName(long VSPP, String name)
+	throws LibvirtException;
+
+	/**
+	 * Create a storage volume within a pool based on an XML description. Not all pools support creation of volumes
+	 * 
+	 * @param xmlDesc description of volume to create
+	 * @param flags flags for creation (unused, pass 0)
+	 * @return the storage volume
+	 * @throws LibvirtException
+	 */
+	public StorageVol storageVolCreateXML(String xmlDesc, int flags)
+	throws LibvirtException {
+		return new StorageVol(virConnect, _storageVolCreateXML(VSPP, xmlDesc, flags));
+	}
+
+	private native long _storageVolCreateXML(long VSPP, String xmlDesc, int flags)
+	throws LibvirtException;
+
+}
Index: src/jni/org_libvirt_StorageVol.c
===================================================================
RCS file: src/jni/org_libvirt_StorageVol.c
diff -N src/jni/org_libvirt_StorageVol.c
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ src/jni/org_libvirt_StorageVol.c	1 Jan 1970 00:00:00 -0000
@@ -0,0 +1,65 @@
+#include "org_libvirt_StorageVol.h"
+#include "generic.h"
+#include <libvirt/libvirt.h>
+
+JNIEXPORT jlong JNICALL Java_org_libvirt_StorageVol__1storagePoolLookupByVolume
+  (JNIEnv *env, jobject obj, jlong VSVP){
+	return generic_lookupBy_none(env, obj, VSVP, (void* (*)(void*))&virStoragePoolLookupByVolume);
+}
+
+JNIEXPORT jint JNICALL Java_org_libvirt_StorageVol__1delete
+  (JNIEnv *env, jobject obj, jlong VSVP, jint flags){
+	return generic__virObj_int__int(env, obj, VSVP, flags, (int (*)(void*, int))&virStorageVolDelete);
+}
+
+JNIEXPORT jint JNICALL Java_org_libvirt_StorageVol__1free
+  (JNIEnv *env, jobject obj, jlong VSVP){
+	return generic__virObj__int(env, obj, VSVP, (int (*)(void*))&virStorageVolFree);
+}
+
+JNIEXPORT jobject JNICALL Java_org_libvirt_StorageVol__1getInfo
+(JNIEnv *env, jobject obj, jlong VSVP){
+
+	virStorageVolInfo storageVolInfo;
+
+	jobject j_info;
+
+	//Get the data
+	if(virStorageVolGetInfo((virStorageVolPtr)VSVP, &storageVolInfo)<0)
+		return NULL;
+
+	//get the field Ids of info
+	jclass j_storageVolInfo_cls = (*env)->FindClass(env,"org/libvirt/StorageVolInfo");
+	jmethodID j_storageVolInfo_constructor = (*env)->GetMethodID(env, j_storageVolInfo_cls, "<init>", "(IJJ)V");
+	
+	//Long live encapsulation
+	j_info=(*env)->NewObject(env,
+					j_storageVolInfo_cls,
+					j_storageVolInfo_constructor,
+					storageVolInfo.type,
+					storageVolInfo.capacity,
+					storageVolInfo.allocation);	
+
+	return j_info;
+}
+
+JNIEXPORT jstring JNICALL Java_org_libvirt_StorageVol__1getKey
+  (JNIEnv *env, jobject obj, jlong VSVP){
+	return generic__virObj__conststring(env, obj, VSVP, (const char* (*)(void*))&virStorageVolGetKey);
+}
+
+JNIEXPORT jstring JNICALL Java_org_libvirt_StorageVol__1getName
+  (JNIEnv *env, jobject obj, jlong VSVP){
+	return generic__virObj__conststring(env, obj, VSVP, (const char* (*)(void*))&virStorageVolGetName);
+}
+
+JNIEXPORT jstring JNICALL Java_org_libvirt_StorageVol__1getPath
+  (JNIEnv *env, jobject obj, jlong VSVP){
+	return generic__virObj__string(env, obj, VSVP, (char* (*)(void*))&virStorageVolGetPath);
+}
+
+JNIEXPORT jstring JNICALL Java_org_libvirt_StorageVol__1getXMLDesc
+  (JNIEnv *env, jobject obj, jlong VSVP, jint flags){
+	return generic__virObj_int__string(env, obj, VSVP, flags, (char* (*)(void*, int))&virStorageVolGetXMLDesc);
+}
+
Index: src/jni/generic.h
===================================================================
RCS file: src/jni/generic.h
diff -N src/jni/generic.h
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ src/jni/generic.h	1 Jan 1970 00:00:00 -0000
@@ -0,0 +1,88 @@
+#ifndef GENERIC_H_
+#define GENERIC_H_
+#include <jni.h>
+#include <libvirt/libvirt.h>
+
+/*
+ * Generic wrapper with a virObj argument returning an int
+ * (for functions like virDomainFree)
+ */
+jint generic__virObj__int
+  (JNIEnv *env, jobject obj, jlong virObj1, int (*virFunc1)(void*));
+
+/*
+ * Generic wrapper with a virObj and an int arguments returning an int
+ * (for functions like virStorageVolDelete)
+ */
+jint generic__virObj_int__int
+  (JNIEnv *env, jobject obj, jlong virObj1, jint arg1, int (*virFunc1)(void*, int));
+
+/*
+ * Generic wrapper with a virObj arguments returning a constant String
+ * (for functions like virNetworkGetBridgeName	)
+ */
+jstring generic__virObj__conststring
+  (JNIEnv *env, jobject obj, jlong virObj1, const char* (*virFunc1)(void*));
+
+/*
+ * Generic wrapper with a virObj arguments returning a String to be freed by the caller
+ * (for functions like virNetworkGetName)
+ */
+jstring generic__virObj__string
+  (JNIEnv *env, jobject obj, jlong virObj1, char* (*virFunc1)(void*));
+
+/*
+ * Generic wrapper with a virObj and an int argument returning a String to be freed by the caller
+ * (for functions like virStoragePoolGetXMLDesc)
+ */
+jstring generic__virObj_int__string
+  (JNIEnv *env, jobject obj, jlong virObj, jint arg1, char* (*virFunc1)(void*, int));
+
+/*
+ * Generic wrapper for the *getAutoStart functions
+ */
+jboolean generic_getAutostart
+  (JNIEnv *env, jobject obj, jlong virObj, int (*VirFunc1)(void*, int*));
+
+/*
+ * Generic wrapper for the *getUUID functions
+ */
+jintArray generic_getUUID
+  (JNIEnv *env, jobject obj, jlong virObj1, int	(*virFunc1)(void*, unsigned char*));
+
+/*
+ * Generic wrapper for the *getUUIDString functions
+ */
+jstring generic_getUUIDString
+  (JNIEnv *env, jobject obj, jlong virObj, int (*virFunc1)(void*, char*));
+
+/*
+ * Generic wrapper for the *List* functions that return an array of strings
+ * virFunc1 is the *List* function
+ * virFunc2 is the corresponding *NumOf* function
+ */
+JNIEXPORT jobjectArray JNICALL generic_list_stringarray
+  (JNIEnv *env, jobject obj, jlong virObj, int (*virFunc1)(void*, char ** const, int), int (*virFunc2)(void*));
+
+/*
+ * Generic wrapper for the *LookupBy* functions that take a string and return a VirObject
+ */
+JNIEXPORT jlong JNICALL generic_lookupBy_string
+  (JNIEnv *env, jobject obj, jlong virObj, jstring j_stringid, void* (*virFunc1)(void*, const char *));
+
+/*
+ * Generic wrapper for the *LookupBy* functions that take no argument and return a VirObject
+ */
+JNIEXPORT jlong JNICALL generic_lookupBy_none
+  (JNIEnv *env, jobject obj, jlong virObj, void* (*virFunc1)(void*));
+
+/*
+ * Generic wrapper for the *CreateXML* and *DefineXML* functions that take no flags and return VirObject
+ */
+JNIEXPORT jlong JNICALL generic_CreateDefineXML
+  (JNIEnv *env, jobject obj, jlong virObj, jstring j_xmlDesc, void*	(*virFunc1)	(void*, const char *));
+
+JNIEXPORT jlong JNICALL generic_CreateDefineXML_with_flags
+  (JNIEnv *env, jobject obj, jlong virObj, jstring j_xmlDesc, jint flags, void*	(*virFunc1)	(void*, const char *, unsigned int));
+
+#endif /*GENERIC_H_*/