jlibusb/LibusbJava/LibusbJava.cpp

/*!	\file
 * 	\brief Java libusb1.0 wrapper
 *
 * 	\copyright	2010-2012 NTB Interstate University of Applied Sciences of Technology Buchs
 * 				This libary is covered by the LGPL, read LGPL.txt for details
 *
 * 	\author 	Roger Millischer <roger.millischer at ntb.ch> (original author)
 * 	\author		Ueli Niederer <ueli.niederer at ntb.ch> (modifications and enhancements)
 *
 * 	\todo Currently all the pointers and handles passed to and received from libusb are coded
 * 		  in long values to get them in JVM.
 * 		  Clebert Suconic ( http://planet.jboss.org/post/pointers_in_jni_c ) suggests a
 * 		  possibly more elegant way to deal with this issue:
 *			Make use of the ByteBuffer-Class delivered by with the native IO package.
 *			(java.nio). As this class is made to store the start pointer to native buffers
 *			we could create a "ByteBuffer" of length 0 where the start address represents
 *			e.g. the handle.  This can  be done using the following JNI Call:
 *			  env->NewDirectByteBuffer(myPointer, 0); // size = 0, you don't want anyone to change it
 */

/********************************************************************************************
 *
 *		Includes
 *
 *******************************************************************************************/
#include <jni.h>
#include <cstddef>
#include <string>
#include <cstdlib>
#include <ctime>

#include <string.h>

#include "libusb.h"
#include "LibusbJava.h"

//#define DEBUGON

/********************************************************************************************
 *
 *		Globals
 *
 *******************************************************************************************/
/* global flag for loading all class, method and field ID references*/
int java_references_loaded = 0;

/* if > 0 an LibusbJava specific error string is set*/
char *libusbJavaError = NULL;
/********************************************************************************************
 *
 *		Macros
 *
 *******************************************************************************************/
/* to set and clear LibusbJava specific errors*/
#define setLibusbJavaError(error) libusbJavaError = error
#define clearLibusbJavaError() libusbJavaError = NULL

/********************************************************************************************
 *
 *		Prototyp and define for callback-function
 *
 *******************************************************************************************/
static void LIBUSB_CALL transfer_callback(struct libusb_transfer *transfer);

static void
		LIBUSB_CALL fd_added_callback(int fd, short events, void *user_data);

static void LIBUSB_CALL fd_removed_callback(int fd, void *user_data);

/********************************************************************************************
 *
 *      Local helper functions
 *
 *******************************************************************************************/
static __inline jbyteArray 	JNICALL 	to_byteArray(JNIEnv *env, const void *data, size_t len);
static __inline void 		JNICALL 	ThrowIfUnsuccessful(JNIEnv *env, int libusb_result);
static __inline void 		JNICALL		ThrowLibusbError(JNIEnv *env, jint code);

/********************************************************************************************
 *
 *		References
 *
 *******************************************************************************************/
/* class references*/
static jclass usb_devClazz, usb_devDescClazz, usb_confDescClazz, usb_intClazz,
		usb_intDescClazz, usb_epDescClazz, usb_cb_clazz, usb_pollfd_clazz;

/* method ID references*/
static jmethodID usb_devMid, usb_devDescMid, usb_confDescMid, usb_intMid,
		usb_intDescMid, usb_epDescMid, usb_transfer_cb_Mid,
		usb_fd_added_cb_Mid, usb_fd_removed_cb_Mid, usb_pollfd_Mid;

/* field ID references*/
/* usb_device*/
static jfieldID usb_devFID_next, usb_devFID_prev, usb_devFID_filename, usb_devFID_bus,
		usb_devFID_descriptor, usb_devFID_config, usb_devFID_devnum,
		usb_devFID_num_children, usb_devFID_children, usb_devFID_devStructAddr;
/* usb_deviceDescriptor */
static jfieldID usb_devDescFID_bLength, usb_devDescFID_bDescriptorType,
		usb_devDescFID_bcdUSB, usb_devDescFID_bDeviceClass,
		usb_devDescFID_bDeviceSubClass, usb_devDescFID_bDeviceProtocol,
		usb_devDescFID_bMaxPacketSize0, usb_devDescFID_idVendor,
		usb_devDescFID_idProduct, usb_devDescFID_bcdDevice,
		usb_devDescFID_iManufacturer, usb_devDescFID_iProduct,
		usb_devDescFID_iSerialNumber, usb_devDescFID_bNumConfigurations;
/* usb_configurationDescriptor*/
static jfieldID usb_confDescFID_bLength, usb_confDescFID_bDescriptorType,
		usb_confDescFID_wTotalLength, usb_confDescFID_bNumInterfaces,
		usb_confDescFID_bConfigurationValue, usb_confDescFID_iConfiguration,
		usb_confDescFID_bmAttributes, usb_confDescFID_MaxPower,
		usb_confDescFID_interface_, usb_confDescFID_extra,
		usb_confDescFID_extralen;
/* usb_interface*/
static jfieldID usb_intFID_altsetting, usb_intFID_num_altsetting;
/* usb_intDesc*/
static jfieldID usb_intDescFID_bLength, usb_intDescFID_bDescriptorType,
		usb_intDescFID_bInterfaceNumber, usb_intDescFID_bAlternateSetting,
		usb_intDescFID_bNumEndpoints, usb_intDescFID_bInterfaceClass,
		usb_intDescFID_bInterfaceSubClass, usb_intDescFID_bInterfaceProtocol,
		usb_intDescFID_iInterface, usb_intDescFID_endpoint,
		usb_intDescFID_extra, usb_intDescFID_extralen;
/* usb_endpointDescriptor*/
static jfieldID usb_epDescFID_bLength, usb_epDescFID_bDescriptorType,
		usb_epDescFID_bEndpointAddress, usb_epDescFID_bmAttributes,
		usb_epDescFID_wMaxPacketSize, usb_epDescFID_bInterval,
		usb_epDescFID_bRefresh, usb_epDescFID_bSynchAddress,
		usb_epDescFID_extra, usb_epDescFID_extralen;
/*Libusb_pollfd*/
static jfieldID usb_pollfdFID_fd, usb_pollfdFID_events;

/********************************************************************************************
 *
 *		Methods
 *
 *******************************************************************************************/

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_set_debug
 * Signature: (JI)V
 ********************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1set_1debug( JNIEnv *env, jclass obj, jlong ctx, jint level) {
	clearLibusbJavaError();
	libusb_context *context = NULL;
	if (ctx) {
		context = (libusb_context*) ((unsigned long) ctx);
	}
	libusb_set_debug(context, level);
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_init
 * Signature: ()J
 ********************************************************************************************/
JNIEXPORT jlong JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1init( JNIEnv *env, jclass obj) {
	int res;
	libusb_context *context;
	clearLibusbJavaError();

	res = libusb_init(&context);

	#ifdef DEBUGON
		printf("res = %i \n", res);
		printf("env = %p\n", env);
		printf("context = %p\n", &context);
	#endif

	if (!res) {
		return (jlong) context;
	} else {
		return (jlong) res;
	}
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_exit
 * Signature: (J)V
 *******************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1exit(JNIEnv *env, jclass obj, jlong ctx) {
	libusb_context *context = NULL;
	clearLibusbJavaError();
	if (ctx) {
		context = (libusb_context*) ((unsigned long) ctx);
	}
	libusb_exit(context);
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_get_device_list
 * Signature: (J)Lch/ntb/inf/libusbJava/Usb_Device;
 ********************************************************************************************/
JNIEXPORT jobject JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1get_1device_1list( JNIEnv *env, jclass obj, jlong ctx) {
	libusb_device **devs;
	libusb_context *context = NULL;
	ssize_t cnt;
	int res, a, i;
	uint8_t c, h, e;

	/* only load class references, method and field ID  once*/
	if (!java_references_loaded) {
		/* find classes and field ids*/
#ifdef DEBUGON
		printf("load references starts\n");
#endif

		/*usb_device*/
		jobject devClazz = env->FindClass("ch/ntb/inf/libusbJava/Usb_Device");//returns a local reference
		usb_devClazz = (jclass)env->NewGlobalRef(devClazz);//make it global
		if (usb_devClazz == NULL) {
			return NULL; /* exception thrown */
		}
		usb_devMid = env->GetMethodID(usb_devClazz, "<init>", "()V");
		if (usb_devMid == NULL) {
			return NULL;
		}

		usb_devFID_next = env->GetFieldID(usb_devClazz, "next", "Lch/ntb/inf/libusbJava/Usb_Device;");
		usb_devFID_prev = env->GetFieldID(usb_devClazz, "prev", "Lch/ntb/inf/libusbJava/Usb_Device;");
		usb_devFID_filename = env->GetFieldID(usb_devClazz, "filename", "Ljava/lang/String;");
		usb_devFID_bus = env->GetFieldID(usb_devClazz, "bus", "Lch/ntb/inf/libusbJava/Usb_Bus;");
		usb_devFID_descriptor = env->GetFieldID(usb_devClazz, "descriptor", "Lch/ntb/inf/libusbJava/Usb_Device_Descriptor;");
		usb_devFID_config = env->GetFieldID(usb_devClazz, "config", "[Lch/ntb/inf/libusbJava/Usb_Config_Descriptor;");
		usb_devFID_devnum = env->GetFieldID(usb_devClazz, "devnum", "B");
		usb_devFID_num_children = env->GetFieldID(usb_devClazz, "num_children", "B");
		usb_devFID_children = env->GetFieldID(usb_devClazz, "children", "Lch/ntb/inf/libusbJava/Usb_Device;");
		usb_devFID_devStructAddr = env->GetFieldID(usb_devClazz, "devStructAddr", "J");

#ifdef DEBUGON
		printf("usb_device references loaded\n");
#endif
		/* usb_device_descriptor*/
		jobject devDescClazz = env->FindClass("ch/ntb/inf/libusbJava/Usb_Device_Descriptor");//returns a local reference
		usb_devDescClazz = (jclass)env->NewGlobalRef(devDescClazz);//make it global
		if (usb_devDescClazz == NULL) {
			return NULL; /* exception thrown */
		}
		usb_devDescMid = env->GetMethodID(usb_devDescClazz, "<init>", "()V");
		if (usb_devDescMid == NULL) {
			return NULL;
		}
		usb_devDescFID_bLength = env->GetFieldID(usb_devDescClazz, "bLength", "B");
		usb_devDescFID_bDescriptorType = env->GetFieldID(usb_devDescClazz, "bDescriptorType", "B");
		usb_devDescFID_bcdUSB = env->GetFieldID(usb_devDescClazz, "bcdUSB", "S");
		usb_devDescFID_bDeviceClass = env->GetFieldID(usb_devDescClazz, "bDeviceClass", "B");
		usb_devDescFID_bDeviceSubClass = env->GetFieldID(usb_devDescClazz, "bDeviceSubClass", "B");
		usb_devDescFID_bDeviceProtocol = env->GetFieldID(usb_devDescClazz, "bDeviceProtocol", "B");
		usb_devDescFID_bMaxPacketSize0 = env->GetFieldID(usb_devDescClazz, "bMaxPacketSize0", "B");
		usb_devDescFID_idVendor = env->GetFieldID(usb_devDescClazz, "idVendor", "S");
		usb_devDescFID_idProduct = env->GetFieldID(usb_devDescClazz, "idProduct", "S");
		usb_devDescFID_bcdDevice = env->GetFieldID(usb_devDescClazz, "bcdDevice", "S");
		usb_devDescFID_iManufacturer = env->GetFieldID(usb_devDescClazz, "iManufacturer", "B");
		usb_devDescFID_iProduct = env->GetFieldID(usb_devDescClazz, "iProduct", "B");
		usb_devDescFID_iSerialNumber = env->GetFieldID(usb_devDescClazz, "iSerialNumber", "B");
		usb_devDescFID_bNumConfigurations = env->GetFieldID(usb_devDescClazz, "bNumConfigurations", "B");


#ifdef DEBUGON
		printf("usb_device_descriptor references loaded\n");
#endif
		/* usb_configuration_descriptor*/
		jobject confDescClazz = env->FindClass("ch/ntb/inf/libusbJava/Usb_Config_Descriptor");//returns a local reference
		usb_confDescClazz = (jclass)env->NewGlobalRef(confDescClazz);//make it global
		if (usb_confDescClazz == NULL) {
			return NULL; /* exception thrown */
		}
		usb_confDescMid = env->GetMethodID(usb_confDescClazz, "<init>", "()V");
		if (usb_confDescMid == NULL) {
			return NULL;
		}

		usb_confDescFID_bLength = env->GetFieldID(usb_confDescClazz, "bLength", "B");
		usb_confDescFID_bDescriptorType = env->GetFieldID(usb_confDescClazz, "bDescriptorType", "B");
		usb_confDescFID_wTotalLength = env->GetFieldID(usb_confDescClazz, "wTotalLength", "S");
		usb_confDescFID_bNumInterfaces = env->GetFieldID(usb_confDescClazz, "bNumInterfaces", "B");
		usb_confDescFID_bConfigurationValue = env->GetFieldID(usb_confDescClazz, "bConfigurationValue", "B");
		usb_confDescFID_iConfiguration = env->GetFieldID(usb_confDescClazz, "iConfiguration", "B");
		usb_confDescFID_bmAttributes = env->GetFieldID(usb_confDescClazz, "bmAttributes", "B");
		usb_confDescFID_MaxPower = env->GetFieldID(usb_confDescClazz, "MaxPower", "B");
		usb_confDescFID_interface_ = env->GetFieldID(usb_confDescClazz, "interface_", "[Lch/ntb/inf/libusbJava/Usb_Interface;");
		usb_confDescFID_extra = env->GetFieldID(usb_confDescClazz, "extra", "[B");
		usb_confDescFID_extralen = env->GetFieldID(usb_confDescClazz, "extralen", "I");
#ifdef DEBUGON
		printf("usb_configuration_descriptor references loaded\n");
#endif
		/* usb_interface*/
		jobject intClazz = env->FindClass("ch/ntb/inf/libusbJava/Usb_Interface");//returns a local reference
		usb_intClazz = (jclass)env->NewGlobalRef(intClazz);//make it global
		if (usb_intClazz == NULL) {
			return NULL; /* exception thrown */
		}
		usb_intMid = env->GetMethodID(usb_intClazz, "<init>", "()V");
		if (usb_intMid == NULL) {
			return NULL;
		}
		usb_intFID_altsetting = env->GetFieldID(usb_intClazz, "altsetting", "[Lch/ntb/inf/libusbJava/Usb_Interface_Descriptor;");
		usb_intFID_num_altsetting = env->GetFieldID(usb_intClazz, "num_altsetting", "I");
#ifdef DEBUGON
		printf("usb_interface references loaded\n");
#endif
		/* usb_interface_descriptor*/
		jobject intDescClazz = env->FindClass( "ch/ntb/inf/libusbJava/Usb_Interface_Descriptor");//returns a local reference
		usb_intDescClazz = (jclass)env->NewGlobalRef(intDescClazz);//make it global
		if (usb_intDescClazz == NULL) {
			return NULL; /* exception thrown */
		}
		usb_intDescMid = env->GetMethodID(usb_intDescClazz, "<init>", "()V");
		if (usb_intDescMid == NULL) {
			return NULL;
		}
		usb_intDescFID_bLength = env->GetFieldID(usb_intDescClazz, "bLength", "B");
		usb_intDescFID_bDescriptorType = env->GetFieldID(usb_intDescClazz, "bDescriptorType", "B");
		usb_intDescFID_bInterfaceNumber = env->GetFieldID(usb_intDescClazz, "bInterfaceNumber", "B");
		usb_intDescFID_bAlternateSetting = env->GetFieldID(usb_intDescClazz, "bAlternateSetting", "B");
		usb_intDescFID_bNumEndpoints = env->GetFieldID(usb_intDescClazz, "bNumEndpoints", "B");
		usb_intDescFID_bInterfaceClass = env->GetFieldID(usb_intDescClazz, "bInterfaceClass", "B");
		usb_intDescFID_bInterfaceSubClass = env->GetFieldID(usb_intDescClazz, "bInterfaceSubClass", "B");
		usb_intDescFID_bInterfaceProtocol = env->GetFieldID(usb_intDescClazz, "bInterfaceProtocol", "B");
		usb_intDescFID_iInterface = env->GetFieldID(usb_intDescClazz, "iInterface", "B");
		usb_intDescFID_endpoint = env->GetFieldID(usb_intDescClazz, "endpoint", "[Lch/ntb/inf/libusbJava/Usb_Endpoint_Descriptor;");
		usb_intDescFID_extra = env->GetFieldID(usb_intDescClazz, "extra", "[B");
		usb_intDescFID_extralen = env->GetFieldID(usb_intDescClazz, "extralen", "I");
#ifdef DEBUGON
		printf("usb_interface_descriptor references loaded\n");
#endif
		/* usb_endpoint_descriptor*/
		jobject epDescClazz = env->FindClass("ch/ntb/inf/libusbJava/Usb_Endpoint_Descriptor");//returns a local reference
		usb_epDescClazz = (jclass)env->NewGlobalRef(epDescClazz);//make it global
		if (usb_epDescClazz == NULL) {
			return NULL; /* exception thrown */
		}
		usb_epDescMid = env->GetMethodID(usb_epDescClazz, "<init>", "()V");
		if (usb_epDescMid == NULL) {
			return NULL;
		}
		usb_epDescFID_bLength = env->GetFieldID(usb_epDescClazz, "bLength", "B");
		usb_epDescFID_bDescriptorType = env->GetFieldID(usb_epDescClazz, "bDescriptorType", "B");
		usb_epDescFID_bEndpointAddress = env->GetFieldID(usb_epDescClazz, "bEndpointAddress", "B");
		usb_epDescFID_bmAttributes = env->GetFieldID(usb_epDescClazz, "bmAttributes", "B");
		usb_epDescFID_wMaxPacketSize = env->GetFieldID(usb_epDescClazz, "wMaxPacketSize", "S");
		usb_epDescFID_bInterval = env->GetFieldID(usb_epDescClazz, "bInterval", "B");
		usb_epDescFID_bRefresh = env->GetFieldID(usb_epDescClazz, "bRefresh", "B");
		usb_epDescFID_bSynchAddress = env->GetFieldID(usb_epDescClazz, "bSynchAddress", "B");
		usb_epDescFID_extra = env->GetFieldID(usb_epDescClazz, "extra", "[B");
		usb_epDescFID_extralen = env->GetFieldID(usb_epDescClazz, "extralen", "I");
#ifdef DEBUGON
		printf("usb_endpoint_descriptor references loaded\n");
#endif
		/*libusb_event*/
		jobject cb_clazz = env->FindClass("ch/ntb/inf/libusbJava/Libusb_event");//returns a local reference
		usb_cb_clazz = (jclass)env->NewGlobalRef(cb_clazz);//make it global
		if (usb_cb_clazz == NULL) {
			printf("load Clazz failed\n");
			return NULL; /*exception thrown*/
		}
		usb_transfer_cb_Mid = env->GetMethodID(usb_cb_clazz, "transferCallback", "()V");
		if (usb_transfer_cb_Mid == NULL) {
			printf("load method transferCallback failed\n");
			return NULL; /* exception thrown */
		}
		usb_fd_added_cb_Mid = env->GetMethodID(usb_cb_clazz, "fdAddedCallback", "(I)V");
		if (usb_fd_added_cb_Mid == NULL) {
			printf("load method fdAddedCallback failed\n");
			return NULL;/* exception thrown */
		}
		usb_fd_removed_cb_Mid = env->GetMethodID(usb_cb_clazz, "fdRemovedCallback", "(I)V");
		if (usb_fd_removed_cb_Mid == NULL) {
			printf("load method fdRemovedCallback failed\n");
			return NULL;/* exception thrown */
		}
#ifdef DEBUGON
		printf("usb_event_descriptor references loaded\n");
#endif
		/*Libusb_pollfd*/
		jobject pollfd_clazz = env->FindClass("ch/ntb/inf/libusbJava/Libusb_pollfd");//returns a local reference
		usb_pollfd_clazz = (jclass)env->NewGlobalRef(pollfd_clazz);//make it global
		if (usb_pollfd_clazz == NULL) {
			return NULL; /*exception thrown*/
		}
		usb_pollfd_Mid = env->GetMethodID(usb_pollfd_clazz, "<init>", "()V");
		if (usb_devMid == NULL) {
			return NULL; /*exception thrown*/
		}
		usb_pollfdFID_fd = env->GetFieldID(usb_pollfd_clazz, "fd", "I");
		usb_pollfdFID_events = env->GetFieldID(usb_pollfd_clazz, "events", "B");
#ifdef DEBUGON
		printf("Libusb_pollfd_descriptor references loaded\n");
#endif
		java_references_loaded = 1;

#ifdef DEBUGON
		printf("libusb_init: Field initialization done \n");
#endif
	}

	/* objects*/
	jobject root_usb_devObj, usb_devObj, usb_devObj_next, usb_devObj_prev,
			usb_devDescObj, usb_confDescObj, usb_intObj, usb_intDescObj,
			usb_epDescObj;

	jobjectArray usb_confDescObjArray, usb_intObjArray, usb_intDescObjArray,
			usb_epDescObjArray;
	clearLibusbJavaError();

	libusb_config_descriptor *conf_desc;
	if (ctx > 0) {
		context = (libusb_context*) ((unsigned long) ctx);
		cnt = libusb_get_device_list(context, &devs);
	} else {
		cnt = libusb_get_device_list(NULL, &devs);
	}
	if (cnt < 0) {
		setLibusbJavaError("libusb_get_device_list: Error on Memory allocation");
		libusb_free_device_list(devs, 1);
		return NULL;
	}

	/*empty list*/
	if (!cnt) {
		libusb_free_device_list(devs, 1);
		usb_devObj = env->NewObject(usb_devClazz, usb_devMid);
		env->SetByteField(usb_devObj, usb_devFID_devnum, -1);
	}
	usb_devObj = NULL;
	usb_devObj_next = NULL;
	usb_devObj_prev = NULL;
	/* create a new object for every device*/
	for (i = 0; i < cnt; i++) {
#ifdef DEBUGON
		printf("libusb_get_device_list: dev %u \n", i);
#endif
		char filename[3];

		libusb_device_descriptor dev_desc;
		res = libusb_get_device_descriptor(devs[i], &dev_desc);

		if (res) {
			/* this shouldn't happen*/
			printf("\t libusb_get _device_list: dev %u coudn't read Devicedescriptor\n",i);
			continue;
		}
		if (dev_desc.bLength != 18) {
			printf("Corrupt Devicedescriptor dev %d\n", i);
			continue;
		}

		if (!usb_devObj) {
			usb_devObj = env->NewObject(usb_devClazz, usb_devMid);
			if (!usb_devObj) {
				setLibusbJavaError("shared library error: Error NewObject (usb_devObj)");
				return NULL;
			}
			root_usb_devObj = usb_devObj;
		}
		usb_devObj_next = NULL;
		if (i < cnt - 1) {
			usb_devObj_next = env->NewObject(usb_devClazz, usb_devMid);
			if (!usb_devObj_next) {
				setLibusbJavaError("shared library error: Error NewObject (usb_devObj_next)");
				return NULL;
			}
		}
		/*fill the fields of the object*/
		env->SetObjectField(usb_devObj, usb_devFID_next, usb_devObj_next);
		env->SetObjectField(usb_devObj, usb_devFID_prev, usb_devObj_prev);
		sprintf(filename, "%03d", libusb_get_device_address(devs[i]));
		env->SetObjectField(usb_devObj, usb_devFID_filename, env->NewStringUTF(filename));/*like the compatibility Layer*/
		env->SetByteField(usb_devObj, usb_devFID_devnum, libusb_get_device_address(devs[i]));
		env->SetByteField(usb_devObj, usb_devFID_num_children, 0);/*Hardcoded to 0, like the compatibility Layer*/
		env->SetObjectField(usb_devObj, usb_devFID_children, NULL);/*Hardcoded to NULL, like the compatibility Layer*/
		env->SetLongField(usb_devObj, usb_devFID_devStructAddr,	(jlong) devs[i]);

		/*device Descriptor*/
		usb_devDescObj = env->NewObject(usb_devDescClazz, usb_devDescMid);
		if (!usb_devDescObj) {
			setLibusbJavaError("shared library error: Error NewObject (usb_devDescObj)");
			return NULL;
		}
		env->SetByteField(usb_devDescObj, usb_devDescFID_bLength, dev_desc.bLength);
		env->SetByteField(usb_devDescObj, usb_devDescFID_bDescriptorType, dev_desc.bDescriptorType);
		env->SetShortField(usb_devDescObj, usb_devDescFID_bcdUSB, dev_desc.bcdUSB);
		env->SetByteField(usb_devDescObj, usb_devDescFID_bDeviceClass, dev_desc.bDeviceClass);
		env->SetByteField(usb_devDescObj, usb_devDescFID_bDeviceSubClass, dev_desc.bDeviceSubClass);
		env->SetByteField(usb_devDescObj, usb_devDescFID_bDeviceProtocol, dev_desc.bDeviceProtocol);
		env->SetByteField(usb_devDescObj, usb_devDescFID_bMaxPacketSize0, dev_desc.bMaxPacketSize0);
		env->SetShortField(usb_devDescObj, usb_devDescFID_idVendor,	dev_desc.idVendor);
		env->SetShortField(usb_devDescObj, usb_devDescFID_idProduct, dev_desc.idProduct);
		env->SetShortField(usb_devDescObj, usb_devDescFID_bcdDevice, dev_desc.bcdDevice);
		env->SetByteField(usb_devDescObj, usb_devDescFID_iManufacturer,	dev_desc.iManufacturer);
		env->SetByteField(usb_devDescObj, usb_devDescFID_iProduct, dev_desc.iProduct);
		env->SetByteField(usb_devDescObj, usb_devDescFID_iSerialNumber,	dev_desc.iSerialNumber);
		env->SetByteField(usb_devDescObj, usb_devDescFID_bNumConfigurations, dev_desc.bNumConfigurations);
		env->SetObjectField(usb_devDescObj, usb_devFID_descriptor, usb_devDescObj);
		env->SetObjectField(usb_devObj, usb_devFID_descriptor, usb_devDescObj);

		/*configuration descriptor*/
		/*Loop through all of the configurations*/
		usb_confDescObjArray = (jobjectArray) env->NewObjectArray(dev_desc.bNumConfigurations, usb_confDescClazz, NULL);
		if (!usb_confDescObjArray) {
			setLibusbJavaError("shared library error: Error NewOjectArray");
			return NULL;
		}
		for (c = 0; c < dev_desc.bNumConfigurations; c++) {
#ifdef DEBUGON
			printf("\t\tlibusb_get_device_list: configuration %u, Dev: %d \n", c, i);
#endif
			res = libusb_get_config_descriptor(devs[i], c, &conf_desc);
			if (res) {
				continue;
			}
			usb_confDescObj	= env->NewObject(usb_confDescClazz, usb_confDescMid);
			if (!usb_confDescObj) {
				setLibusbJavaError("shared library error: Error NewObject (usb_confDescObj)");
				return NULL;
			}
			env->SetObjectArrayElement(usb_confDescObjArray, c, usb_confDescObj);/*add it to the Array*/
			/*fill the fields*/
			env->SetByteField(usb_confDescObj, usb_confDescFID_bLength, conf_desc->bLength);
			env->SetByteField(usb_confDescObj, usb_confDescFID_bDescriptorType, conf_desc->bDescriptorType);
			env->SetShortField(usb_confDescObj, usb_confDescFID_wTotalLength, conf_desc->wTotalLength);
			env->SetByteField(usb_confDescObj, usb_confDescFID_bNumInterfaces, conf_desc->bNumInterfaces);
			env->SetByteField(usb_confDescObj, usb_confDescFID_bConfigurationValue, conf_desc->bConfigurationValue);
			env->SetByteField(usb_confDescObj, usb_confDescFID_iConfiguration, conf_desc->iConfiguration);
			env->SetByteField(usb_confDescObj, usb_confDescFID_bmAttributes, conf_desc->bmAttributes);
			env->SetByteField(usb_confDescObj, usb_confDescFID_MaxPower, conf_desc->MaxPower);
			env->SetIntField(usb_confDescObj, usb_confDescFID_extralen, conf_desc->extra_length);
			if (conf_desc->extra) {
				jbyteArray jbExtraDesc = to_byteArray(env, conf_desc->extra, conf_desc->extra_length);
				env->SetObjectField(usb_confDescObj, usb_confDescFID_extra, jbExtraDesc);
			} else {
				env->SetObjectField(usb_confDescObj, usb_confDescFID_extra,	NULL);
			}
			/*interface*/
			usb_intObjArray = (jobjectArray) env->NewObjectArray(conf_desc->bNumInterfaces, usb_intClazz, NULL);
			if (!usb_intObjArray) {
				setLibusbJavaError("shared library error: Error NewObjectArray (usb_intObjArray)");
				return NULL;
			}
			for (h = 0; h < conf_desc->bNumInterfaces; h++) {
#ifdef DEBUGON
				printf("\t\t\tlibusb_get_device_list: interface %u \n", h);
#endif

				if (conf_desc->interface == NULL) {
					/* this shouldn't happen*/
					printf("(*conf_desc)->usb_interface == NULL");
					continue;
				}
				usb_intObj = env->NewObject(usb_intClazz, usb_intMid);
				if (!usb_intObj) {
					setLibusbJavaError("shared library error: Error NewObject (usb_intObj)");
					return NULL;
				}
				env->SetObjectArrayElement(usb_intObjArray, h, usb_intObj);
				env->SetIntField(usb_intObj, usb_intFID_num_altsetting,	conf_desc->interface[h].num_altsetting);
				// interface descriptor
				usb_intDescObjArray = (jobjectArray) env->NewObjectArray( conf_desc->interface[h].num_altsetting, usb_intDescClazz, NULL);
				if (!usb_intDescObjArray) {
					setLibusbJavaError("shared library error: Error NewObjectArray (usb_intDescObjArray)");
					return NULL;
				}
				for (a = 0; a < conf_desc->interface[h].num_altsetting; a++) {
#ifdef DEBUGON
					printf("\t\t\t\tlibusb_get_device_list: interface descriptor %u \n", a);
#endif
					if (conf_desc->interface[h].altsetting == NULL) {
						// this shouldn't happen
						printf("LibusbJava: libusb_get_device_list: (*conf_desc)->interface->altsetting == NULL\n");
						continue;
					}
					usb_intDescObj = env->NewObject(usb_intDescClazz, usb_intDescMid);
					if (!usb_intDescObj) {
						setLibusbJavaError("shared library error: Error NewObject (usb_intDescObj)");
						return NULL;
					}
					env->SetObjectArrayElement(usb_intDescObjArray, a, usb_intDescObj);
					/*fill fields*/
					env->SetByteField(usb_intDescObj, usb_intDescFID_bLength, conf_desc->interface[h].altsetting[a].bLength);
					env->SetByteField(usb_intDescObj, usb_intDescFID_bDescriptorType, conf_desc->interface[h].altsetting[a].bDescriptorType);
					env->SetByteField(usb_intDescObj, usb_intDescFID_bInterfaceNumber, conf_desc->interface[h].altsetting[a].bInterfaceNumber);
					env->SetByteField(usb_intDescObj, usb_intDescFID_bAlternateSetting, conf_desc->interface[h].altsetting[a].bAlternateSetting);
					env->SetByteField(usb_intDescObj, usb_intDescFID_bNumEndpoints, conf_desc->interface[h].altsetting[a].bNumEndpoints);
					env->SetByteField(usb_intDescObj, usb_intDescFID_bInterfaceClass, conf_desc->interface[h].altsetting[a].bInterfaceClass);
					env->SetByteField(usb_intDescObj, usb_intDescFID_bInterfaceSubClass, conf_desc->interface[h].altsetting[a].bInterfaceSubClass);
					env->SetByteField(usb_intDescObj, usb_intDescFID_bInterfaceProtocol, conf_desc->interface[h].altsetting[a].bInterfaceProtocol);
					env->SetByteField(usb_intDescObj, usb_intDescFID_iInterface, conf_desc->interface[h].altsetting[a].iInterface);
					env->SetIntField(usb_intDescObj, usb_intDescFID_extralen, conf_desc->interface[h].altsetting[a].extra_length);
					if (conf_desc->interface[h].altsetting[a].extra) {
						jbyteArray jbExtraDesc = to_byteArray(env, conf_desc->interface[h].altsetting[a].extra, conf_desc->interface[h].altsetting[a].extra_length);
						env->SetObjectField(usb_intDescObj, usb_intDescFID_extra, jbExtraDesc);
					} else {
						env->SetObjectField(usb_intDescObj,	usb_intDescFID_extra, NULL);
					}
					/*endpoint descriptor*/
					usb_epDescObjArray = (jobjectArray) env->NewObjectArray( conf_desc->interface[h].altsetting[a].bNumEndpoints, usb_epDescClazz, NULL);
					if (!usb_epDescObjArray) {
						setLibusbJavaError("shared library error: Error NewObjectArray (usb_epDescObjArray)");
						return NULL;
					}
					for (e = 0; e < conf_desc->interface[h].altsetting[a].bNumEndpoints; e++) {
#ifdef DEBUGON
						printf("\t\t\t\t\tLibusb_get_device_list: endpoint descriptor %u \n",e);
#endif


						if (conf_desc->interface[h].altsetting[a].endpoint == NULL) {
							printf(	"LibusbJava: usb_get_busses: (*conf_desc)->interface->altsetting->endpoint == NULL\n");
							return root_usb_devObj;
						}
						usb_epDescObj = env->NewObject(usb_epDescClazz,	usb_epDescMid);
						if (!usb_epDescObj) {
							setLibusbJavaError("shared library error: Error NewObject (usb_epDescObj)");
							return NULL;
						}
						env->SetObjectArrayElement(usb_epDescObjArray, e, usb_epDescObj);
						env->SetByteField(usb_epDescObj, usb_epDescFID_bLength, conf_desc->interface[h].altsetting[a].endpoint[e].bLength);
						env->SetByteField(usb_epDescObj, usb_epDescFID_bDescriptorType, conf_desc->interface[h].altsetting[a].endpoint[e].bDescriptorType);
						env->SetByteField(usb_epDescObj, usb_epDescFID_bEndpointAddress, conf_desc->interface[h].altsetting[a].endpoint[e].bEndpointAddress);
						env->SetByteField(usb_epDescObj, usb_epDescFID_bmAttributes, conf_desc->interface[h].altsetting[a].endpoint[e].bmAttributes);
						env->SetShortField(usb_epDescObj, usb_epDescFID_wMaxPacketSize, conf_desc->interface[h].altsetting[a].endpoint[e].wMaxPacketSize);
						env->SetByteField(usb_epDescObj, usb_epDescFID_bInterval, conf_desc->interface[h].altsetting[a].endpoint[e].bInterval);
						env->SetByteField(usb_epDescObj, usb_epDescFID_bRefresh, conf_desc->interface[h].altsetting[a].endpoint[e].bRefresh);
						env->SetByteField(usb_epDescObj, usb_epDescFID_bSynchAddress, conf_desc->interface[h].altsetting[a].endpoint[e].bSynchAddress);
						env->SetIntField(usb_epDescObj, usb_epDescFID_extralen, conf_desc->interface[h].altsetting[a].endpoint[e].extra_length);
						if (conf_desc->interface[h].altsetting[a].endpoint[e].extra) {
							jbyteArray jbExtraDesc = to_byteArray(env,  conf_desc->interface[h].altsetting[a].endpoint[e].extra, conf_desc->interface[h].altsetting[a].endpoint[e].extra_length);
							env->SetObjectField(usb_epDescObj, usb_epDescFID_extra, jbExtraDesc);
						} else {
							env->SetObjectField(usb_epDescObj, usb_epDescFID_extra, NULL);
						}
					}
					env->SetObjectField(usb_intDescObj, usb_intDescFID_endpoint, usb_epDescObjArray);
				}
				env->SetObjectField(usb_intObj, usb_intFID_altsetting, usb_intDescObjArray);
			}
			env->SetObjectField(usb_confDescObj, usb_confDescFID_interface_, usb_intObjArray);
			libusb_free_config_descriptor(conf_desc);
		}
		if (res) {
			env->SetLongField(usb_devObj, usb_devFID_devStructAddr, (jlong) 0);
			continue;
		}
		env->SetObjectField(usb_devObj, usb_devFID_config, usb_confDescObjArray);
		usb_devObj_prev = usb_devObj;
		usb_devObj = usb_devObj_next;

	}
	//Eliminate empty last device
	env->SetObjectField(usb_devObj_prev, usb_devFID_next, NULL);

//	free(dev_desc);
	libusb_free_device_list(devs, 0);
#ifdef DEBUGON
	printf("libusb_get_device_list: done\n");
#endif
	return root_usb_devObj;
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_get_bus_number
 * Signature: (Lch/ntb/inf/libusbJava/Usb_Device;)S
 ********************************************************************************************/
JNIEXPORT jshort JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1get_1bus_1number( JNIEnv *env, jclass obj, jobject dev) {
	clearLibusbJavaError();
	libusb_device *libusb_dev = (libusb_device *) (long) env->GetLongField(dev,	usb_devFID_devStructAddr);
	return libusb_get_bus_number(libusb_dev);
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_get_max_iso_packet_size
 * Signature: (Lch/ntb/inf/libusbJava/Usb_Device;S)I
 ********************************************************************************************/
JNIEXPORT jint
JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1get_1max_1iso_1packet_1size( JNIEnv *env, jclass obj, jobject dev, jshort epAddr) {
	clearLibusbJavaError();
	libusb_device *libusb_dev = (libusb_device *) (unsigned long) env->GetLongField(dev, usb_devFID_devStructAddr);
	return libusb_get_max_iso_packet_size(libusb_dev, epAddr);
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_ref_device
 * Signature: (Lch/ntb/inf/libusbJava/Usb_Device;)Lch/ntb/inf/libusbJava/Usb_Device;
 ********************************************************************************************/
JNIEXPORT jobject JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1ref_1device(JNIEnv *env, jclass obj, jobject dev) {
	clearLibusbJavaError();
	libusb_device *libusb_dev =	(libusb_device *) (unsigned long) env->GetLongField(dev, usb_devFID_devStructAddr);
	libusb_ref_device(libusb_dev);
	return dev;
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_unref_device
 * Signature: (Lch/ntb/inf/libusbJava/Usb_Device;)V
 ********************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1unref_1device(JNIEnv *env, jclass obj, jobject dev) {
	clearLibusbJavaError();
	libusb_device *libusb_dev =	(libusb_device *) (unsigned long) env->GetLongField(dev,usb_devFID_devStructAddr);
	libusb_unref_device(libusb_dev);
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_open
 * Signature: (Lch/ntb/inf/libusbJava/Usb_Device;)J
 ********************************************************************************************/
JNIEXPORT jlong JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1open( JNIEnv *env, jclass obj, jobject dev) {
	clearLibusbJavaError();
	libusb_device_handle *handle = NULL;
	libusb_device *libusb_dev =	(libusb_device *) (unsigned long) env->GetLongField(dev, usb_devFID_devStructAddr);
	int res = libusb_open(libusb_dev, &handle);

	if(res != 0)
	{
		ThrowLibusbError(env, res);
		handle = NULL;
	}

	return (jlong)handle;
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_open_device_with_vid_pid
 * Signature: (JII)J
 ********************************************************************************************/
JNIEXPORT jlong
JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1open_1device_1with_1vid_1pid(JNIEnv *env, jclass obj, jlong ctx, jint vendor_id, jint product_id) {
	clearLibusbJavaError();
	return (jlong) libusb_open_device_with_vid_pid((libusb_context*) (unsigned long) ctx, vendor_id, product_id);
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_close
 * Signature: (J)V
 ********************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1close(JNIEnv *env, jclass obj, jlong dev_handle) {
	clearLibusbJavaError();
	libusb_close((libusb_device_handle*) (unsigned long) dev_handle);
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_get_device
 * Signature: (J)Lch/ntb/inf/libusbJava/Usb_Device;
 ********************************************************************************************/
JNIEXPORT jobject JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1get_1device(JNIEnv *env, jclass obj, jlong handle) {
	int res, a;
	uint8_t c, h, e;
	char filename[3];
	clearLibusbJavaError();
	libusb_config_descriptor *conf_desc;
	struct libusb_device_descriptor dev_desc;
	libusb_device *lib_dev = libusb_get_device((libusb_device_handle*) (unsigned long) handle);

	/* objects*/
	jobject usb_devObj, usb_devDescObj, usb_confDescObj, usb_intObj, usb_intDescObj, usb_epDescObj;
	jobjectArray usb_confDescObjArray, usb_intObjArray, usb_intDescObjArray, usb_epDescObjArray;

	/* create a new object for device*/
	libusb_get_device_descriptor(lib_dev, &dev_desc);
	usb_devObj = env->NewObject(usb_devClazz, usb_devMid);
	if (!usb_devObj) {
		setLibusbJavaError("shared library error: Error NewObject (usb_devObj)");
		return NULL;
	}

	/*fill the fields of the object*/
	env->SetObjectField(usb_devObj, usb_devFID_next, NULL);
	env->SetObjectField(usb_devObj, usb_devFID_prev, NULL);

	sprintf(filename, "%03d", libusb_get_device_address(lib_dev));
	env->SetObjectField(usb_devObj, usb_devFID_filename, env->NewStringUTF(filename));/*like the compatibility Layer*/
	env->SetByteField(usb_devObj, usb_devFID_devnum, libusb_get_device_address(lib_dev));
	env->SetByteField(usb_devObj, usb_devFID_num_children, 0);/*Hardcoded to 0, like the compatibility Layer*/
	env->SetObjectField(usb_devObj, usb_devFID_children, NULL);/*Hardcoded to NULL, like the compatibility Layer*/
	env->SetLongField(usb_devObj, usb_devFID_devStructAddr,(jlong) lib_dev);

	/*device Descriptor*/
	usb_devDescObj = env->NewObject(usb_devDescClazz, usb_devDescMid);
	if (!usb_devDescObj) {
		setLibusbJavaError("shared library error: Error NewObject (usb_devDescObj)");
		return NULL;
	}
	env->SetByteField(usb_devDescObj, usb_devDescFID_bLength, dev_desc.bLength);
	env->SetByteField(usb_devDescObj, usb_devDescFID_bDescriptorType, dev_desc.bDescriptorType);
	env->SetShortField(usb_devDescObj, usb_devDescFID_bcdUSB, dev_desc.bcdUSB);
	env->SetByteField(usb_devDescObj, usb_devDescFID_bDeviceClass, dev_desc.bDeviceClass);
	env->SetByteField(usb_devDescObj, usb_devDescFID_bDeviceSubClass, dev_desc.bDeviceSubClass);
	env->SetByteField(usb_devDescObj, usb_devDescFID_bDeviceProtocol, dev_desc.bDeviceProtocol);
	env->SetByteField(usb_devDescObj, usb_devDescFID_bMaxPacketSize0, dev_desc.bMaxPacketSize0);
	env->SetShortField(usb_devDescObj, usb_devDescFID_idVendor, dev_desc.idVendor);
	env->SetShortField(usb_devDescObj, usb_devDescFID_idProduct, dev_desc.idProduct);
	env->SetShortField(usb_devDescObj, usb_devDescFID_bcdDevice, dev_desc.bcdDevice);
	env->SetByteField(usb_devDescObj, usb_devDescFID_iManufacturer, dev_desc.iManufacturer);
	env->SetByteField(usb_devDescObj, usb_devDescFID_iProduct, dev_desc.iProduct);
	env->SetByteField(usb_devDescObj, usb_devDescFID_iSerialNumber, dev_desc.iSerialNumber);
	env->SetByteField(usb_devDescObj, usb_devDescFID_bNumConfigurations, dev_desc.bNumConfigurations);
	env->SetObjectField(usb_devDescObj, usb_devFID_descriptor, usb_devDescObj);

	/*configuration descriptor*/
	/*Loop through all of the configurations*/
	usb_confDescObjArray = (jobjectArray) env->NewObjectArray(
			dev_desc.bNumConfigurations, usb_confDescClazz, NULL);
	if (!usb_confDescObjArray) {
		setLibusbJavaError("shared library error: Error NewOjectArray");
		return NULL;
	}
	for (c = 0; c < dev_desc.bNumConfigurations; c++) {
#ifdef DEBUGON
		printf("\t\tlibusb_get_device: configuration %u \n", c);
#endif
		res = libusb_get_config_descriptor(lib_dev, c, &conf_desc);
		if (res) {
			setLibusbJavaError("shared library error: read conf_desc failed");
			return usb_devObj;
		}

		usb_confDescObj = env->NewObject(usb_confDescClazz, usb_confDescMid);
		if (!usb_confDescObj) {
			setLibusbJavaError("shared library error: Error NewObject (usb_confDescObj)");
			return NULL;
		}
		env->SetObjectArrayElement(usb_confDescObjArray, c, usb_confDescObj);/*add it to the Array*/
		/*fill the fields*/
		env->SetByteField(usb_confDescObj, usb_confDescFID_bLength,	conf_desc->bLength);
		env->SetByteField(usb_confDescObj, usb_confDescFID_bDescriptorType, conf_desc->bDescriptorType);
		env->SetShortField(usb_confDescObj, usb_confDescFID_wTotalLength, conf_desc->wTotalLength);
		env->SetByteField(usb_confDescObj, usb_confDescFID_bNumInterfaces, conf_desc->bNumInterfaces);
		env->SetByteField(usb_confDescObj, usb_confDescFID_bConfigurationValue, conf_desc->bConfigurationValue);
		env->SetByteField(usb_confDescObj, usb_confDescFID_iConfiguration, conf_desc->iConfiguration);
		env->SetByteField(usb_confDescObj, usb_confDescFID_bmAttributes, conf_desc->bmAttributes);
		env->SetByteField(usb_confDescObj, usb_confDescFID_MaxPower, conf_desc->MaxPower);
		env->SetIntField(usb_confDescObj, usb_confDescFID_extralen, conf_desc->extra_length);
		if (conf_desc->extra) {
			jbyteArray jbExtraDesc = to_byteArray(env, conf_desc->extra, conf_desc->extra_length);
			env->SetObjectField(usb_confDescObj, usb_confDescFID_extra, jbExtraDesc);
		} else {
			env->SetObjectField(usb_confDescObj, usb_confDescFID_extra, NULL);
		}
		/*interface*/
		usb_intObjArray = (jobjectArray) env->NewObjectArray(conf_desc->bNumInterfaces, usb_intClazz, NULL);
		if (!usb_intObjArray) {
			setLibusbJavaError("shared library error: Error NewObjectArray (usb_intObjArray)");
			return NULL;
		}
		for (h = 0; h < conf_desc->bNumInterfaces; h++) {
#ifdef DEBUGON
			printf("\t\t\tlibusb_get_device: interface %u \n", h);
#endif

			if (conf_desc->interface == NULL) {
				// this shouldn't happen
				printf("(*conf_desc)->usb_interface == NULL");
				continue;
			}
			usb_intObj = env->NewObject(usb_intClazz, usb_intMid);
			if (!usb_intObj) {
				setLibusbJavaError("shared library error: Error NewObject (usb_intObj)");
				return NULL;
			}
			env->SetObjectArrayElement(usb_intObjArray, h, usb_intObj);
			env->SetIntField(usb_intObj, usb_intFID_num_altsetting,	conf_desc->interface[h].num_altsetting);
			// interface descriptor
			usb_intDescObjArray = (jobjectArray) env->NewObjectArray(conf_desc->interface[h].num_altsetting, usb_intDescClazz, NULL);
			if (!usb_intDescObjArray) {
				setLibusbJavaError("shared library error: Error NewObjectArray (usb_intDescObjArray)");
				return NULL;
			}
			for (a = 0; a < conf_desc->interface[h].num_altsetting; a++) {
#ifdef DEBUGON
				printf("\t\t\t\tlibusb_get_device: interface descriptor %u \n",	a);
#endif

				if (conf_desc->interface[h].altsetting == NULL) {
					// this shouldn't happen
					printf("LibusbJava: libusb_get_device_list: altsetting == NULL\n");
					continue;
				}
				usb_intDescObj = env->NewObject(usb_intDescClazz, usb_intDescMid);
				if (!usb_intDescObj) {
					setLibusbJavaError("shared library error: Error NewObject (usb_intDescObj)");
					return NULL;
				}
				env->SetObjectArrayElement(usb_intDescObjArray, a, usb_intDescObj);
				/*fill fields*/
				env->SetByteField(usb_intDescObj, usb_intDescFID_bLength, conf_desc->interface[h].altsetting[a].bLength);
				env->SetByteField(usb_intDescObj, usb_intDescFID_bDescriptorType, conf_desc->interface[h].altsetting[a].bDescriptorType);
				env->SetByteField(usb_intDescObj, usb_intDescFID_bInterfaceNumber, conf_desc->interface[h].altsetting[a].bInterfaceNumber);
				env->SetByteField(usb_intDescObj, usb_intDescFID_bAlternateSetting, conf_desc->interface[h].altsetting[a].bAlternateSetting);
				env->SetByteField(usb_intDescObj, usb_intDescFID_bNumEndpoints, conf_desc->interface[h].altsetting[a].bNumEndpoints);
				env->SetByteField(usb_intDescObj, usb_intDescFID_bInterfaceClass, conf_desc->interface[h].altsetting[a].bInterfaceClass);
				env->SetByteField(usb_intDescObj, usb_intDescFID_bInterfaceSubClass, conf_desc->interface[h].altsetting[a].bInterfaceSubClass);
				env->SetByteField(usb_intDescObj, usb_intDescFID_bInterfaceProtocol, conf_desc->interface[h].altsetting[a].bInterfaceProtocol);
				env->SetByteField(usb_intDescObj, usb_intDescFID_iInterface, conf_desc->interface[h].altsetting[a].iInterface);
				env->SetIntField(usb_intDescObj, usb_intDescFID_extralen, conf_desc->interface[h].altsetting[a].extra_length);
				if (conf_desc->interface[h].altsetting[a].extra) {
					jbyteArray jbExtraDesc = to_byteArray(env, conf_desc->interface[h].altsetting[a].extra, conf_desc->interface[h].altsetting[a].extra_length);
					env->SetObjectField(usb_intDescObj, usb_intDescFID_extra, jbExtraDesc);
				} else {
					env->SetObjectField(usb_intDescObj, usb_intDescFID_extra, NULL);
				}
				/*endpoint descriptor*/
				usb_epDescObjArray = (jobjectArray) env->NewObjectArray(conf_desc->interface[h].altsetting[a].bNumEndpoints, usb_epDescClazz, NULL);
				if (!usb_epDescObjArray) {
					setLibusbJavaError("shared library error: Error NewObjectArray (usb_epDescObjArray)");
					return NULL;
				}
				for (e = 0; e < conf_desc->interface[h].altsetting[a].bNumEndpoints; e++) {
#ifdef DEBUGON
					printf("\t\t\t\t\tLibusb_get_device: endpoint descriptor %u \n", e);
#endif

					if (conf_desc->interface[h].altsetting[a].endpoint == NULL) {
						printf("LibusbJava: usb_get_busses: endpoint == NULL\n");
						return usb_devObj;
					}
					usb_epDescObj = env->NewObject(usb_epDescClazz,	usb_epDescMid);
					if (!usb_epDescObj) {
						setLibusbJavaError("shared library error: Error NewObject (usb_epDescObj)");
						return NULL;
					}
					env->SetObjectArrayElement(usb_epDescObjArray, e, usb_epDescObj);
					env->SetByteField(usb_epDescObj, usb_epDescFID_bLength, conf_desc->interface[h].altsetting[a].endpoint[e].bLength);
					env->SetByteField(usb_epDescObj, usb_epDescFID_bDescriptorType, conf_desc->interface[h].altsetting[a].endpoint[e].bDescriptorType);
					env->SetByteField(usb_epDescObj, usb_epDescFID_bEndpointAddress, conf_desc->interface[h].altsetting[a].endpoint[e].bEndpointAddress);
					env->SetByteField(usb_epDescObj, usb_epDescFID_bmAttributes, conf_desc->interface[h].altsetting[a].endpoint[e].bmAttributes);
					env->SetShortField(usb_epDescObj, usb_epDescFID_wMaxPacketSize, conf_desc->interface[h].altsetting[a].endpoint[e].wMaxPacketSize);
					env->SetByteField(usb_epDescObj, usb_epDescFID_bInterval, conf_desc->interface[h].altsetting[a].endpoint[e].bInterval);
					env->SetByteField(usb_epDescObj, usb_epDescFID_bRefresh, conf_desc->interface[h].altsetting[a].endpoint[e].bRefresh);
					env->SetByteField(usb_epDescObj, usb_epDescFID_bSynchAddress, conf_desc->interface[h].altsetting[a].endpoint[e].bSynchAddress);
					env->SetIntField(usb_epDescObj, usb_epDescFID_extralen, conf_desc->interface[h].altsetting[a].endpoint[e].extra_length);
					if (conf_desc->interface[h].altsetting[a].endpoint[e].extra) {
						jbyteArray jbExtraDesc = to_byteArray(env, conf_desc->interface[h].altsetting[a].endpoint[e].extra, conf_desc->interface[h].altsetting[a].endpoint[e].extra_length);
						env->SetObjectField(usb_epDescObj, usb_epDescFID_extra, jbExtraDesc);
					} else {
						env->SetObjectField(usb_epDescObj, usb_epDescFID_extra, NULL);
					}
				}
				env->SetObjectField(usb_intDescObj, usb_intDescFID_endpoint, usb_epDescObjArray);
			}
			env->SetObjectField(usb_intObj, usb_intFID_altsetting, usb_intDescObjArray);
		}
		env->SetObjectField(usb_confDescObj, usb_confDescFID_interface_, usb_intObjArray);
		libusb_free_config_descriptor(conf_desc);
	}
	env->SetObjectField(usb_devObj, usb_devFID_config, usb_confDescObjArray);

#ifdef DEBUGON
	printf("libusb_get_device: done\n");
#endif
	return usb_devObj;
}
/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_get_configuration
 * Signature: (J)I
 ********************************************************************************************/
JNIEXPORT jint JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1get_1configuration(JNIEnv *env, jclass obj, jlong handle) {
	int config = 0;
	int libusb_result = 0;

	clearLibusbJavaError();
	libusb_result = libusb_get_configuration((libusb_device_handle*) (unsigned long) handle, &config);

	if (libusb_result != 0) {
		setLibusbJavaError("shared library error: get_configuration failed");
		ThrowLibusbError(env, libusb_result);
		config = 0;
	}

	return config;
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_set_configuration
 * Signature: (JI)V
 ********************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1set_1configuration(JNIEnv *env, jclass obj, jlong handle, jint config) {
	clearLibusbJavaError();
	ThrowIfUnsuccessful(env, libusb_set_configuration((libusb_device_handle*) (unsigned long) handle, config));
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_claim_interface
 * Signature: (JI)V
 ********************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1claim_1interface(JNIEnv *env, jclass obj, jlong handle, jint iNumber) {
	clearLibusbJavaError();
	ThrowIfUnsuccessful(env, libusb_claim_interface((libusb_device_handle*) (unsigned long) handle, iNumber));
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_release_interface
 * Signature: (JI)V
 ********************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1release_1interface(JNIEnv *env, jclass obj, jlong handle, jint iNumber) {
	clearLibusbJavaError();
	ThrowIfUnsuccessful(env, libusb_release_interface((libusb_device_handle*) (unsigned long) handle, iNumber));
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_set_interface_alt_setting
 * Signature: (JII)V
 ********************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1set_1interface_1alt_1setting(JNIEnv *env, jclass obj, jlong handle, jint iNumber, jint altSet) {
	clearLibusbJavaError();
	ThrowIfUnsuccessful(env, libusb_set_interface_alt_setting((libusb_device_handle*) (unsigned long) handle, iNumber, altSet));
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_clear_halt
 * Signature: (JS)V
 ********************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1clear_1halt(JNIEnv *env, jclass obj, jlong handle, jshort ep) {
	clearLibusbJavaError();
	ThrowIfUnsuccessful(env, libusb_clear_halt((libusb_device_handle*) (unsigned long) handle, ep));
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_reset_device
 * Signature: (J)V
 ********************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1reset_1device(JNIEnv *env, jclass obj, jlong handle) {
	clearLibusbJavaError();
	ThrowIfUnsuccessful(env, libusb_reset_device((libusb_device_handle*) (unsigned long) handle));
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_kernel_driver_active
 * Signature: (JI)I
 ********************************************************************************************/
JNIEXPORT jint JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1kernel_1driver_1active(JNIEnv *env, jclass obj, jlong handle, jint iNumber) {
	int libusb_result = 0;

	clearLibusbJavaError();
	libusb_result = libusb_kernel_driver_active((libusb_device_handle*) (unsigned long) handle, iNumber);

	if (libusb_result < 0)
	{
		ThrowLibusbError(env, libusb_result);
		libusb_result = 0;
	}

	return libusb_result;
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_detach_kernel_driver
 * Signature: (JI)V
 ********************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1detach_1kernel_1driver(JNIEnv *env, jclass obj, jlong handle, jint iNumber) {
	clearLibusbJavaError();
	ThrowIfUnsuccessful(env, libusb_detach_kernel_driver((libusb_device_handle*) (unsigned long) handle, iNumber));
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_attach_kernel_driver
 * Signature: (JI)V
 ********************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1attach_1kernel_1driver(JNIEnv *env, jclass obj, jlong handle, jint iNumber) {
	clearLibusbJavaError();
	ThrowIfUnsuccessful(env, libusb_attach_kernel_driver((libusb_device_handle*) (unsigned long) handle, iNumber));
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_get_active_config_descriptor
 * Signature: (Lch/ntb/inf/libusbJava/Usb_Device;)Lch/ntb/inf/libusbJava/Usb_Config_Descriptor;
 ********************************************************************************************/
JNIEXPORT jobject JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1get_1active_1config_1descriptor(JNIEnv *env, jclass obj, jobject dev) {
	uint8_t a, e;
	clearLibusbJavaError();
	libusb_config_descriptor *conf_desc;
	jobject usb_confDescObj, usb_intObj, usb_intDescObj, usb_epDescObj;
	jobjectArray usb_intObjArray, usb_intDescObjArray, usb_epDescObjArray;

	libusb_device *lib_dev = (libusb_device*) (unsigned long) env->GetLongField(dev, usb_devFID_devStructAddr);
	if (libusb_get_active_config_descriptor(lib_dev, &conf_desc)) {
		setLibusbJavaError("shared library error: get_configuration failed");
		return NULL;
	}
	usb_confDescObj = env->NewObject(usb_confDescClazz, usb_confDescMid);
	if (!usb_confDescObj) {
		setLibusbJavaError("shared library error: Error NewObject (usb_confDescObj)");
		return NULL;
	}
	/*fill the fields*/
	env->SetByteField(usb_confDescObj, usb_confDescFID_bLength,	conf_desc->bLength);
	env->SetByteField(usb_confDescObj, usb_confDescFID_bDescriptorType, conf_desc->bDescriptorType);
	env->SetShortField(usb_confDescObj, usb_confDescFID_wTotalLength, conf_desc->wTotalLength);
	env->SetByteField(usb_confDescObj, usb_confDescFID_bNumInterfaces, conf_desc->bNumInterfaces);
	env->SetByteField(usb_confDescObj, usb_confDescFID_bConfigurationValue, conf_desc->bConfigurationValue);
	env->SetByteField(usb_confDescObj, usb_confDescFID_iConfiguration, conf_desc->iConfiguration);
	env->SetByteField(usb_confDescObj, usb_confDescFID_bmAttributes, conf_desc->bmAttributes);
	env->SetByteField(usb_confDescObj, usb_confDescFID_MaxPower, conf_desc->MaxPower);
	env->SetIntField(usb_confDescObj, usb_confDescFID_extralen, conf_desc->extra_length);
	if (conf_desc->extra) {
		jbyteArray jbExtraDesc = to_byteArray(env, conf_desc->extra, conf_desc->extra_length);
		env->SetObjectField(usb_confDescObj, usb_confDescFID_extra, jbExtraDesc);
	} else {
		env->SetObjectField(usb_confDescObj, usb_confDescFID_extra, NULL);
	}
	/*interface*/
	usb_intObjArray = (jobjectArray) env->NewObjectArray(conf_desc->bNumInterfaces, usb_intClazz, NULL);
	if (!usb_intObjArray) {
		setLibusbJavaError("shared library error: Error NewObjectArray (usb_intObjArray)");
		return NULL;
	}
	for (int i = 0; i < conf_desc->bNumInterfaces; i++) {
#ifdef DEBUGON
		printf("\t\t\tlibusb_get_activ_config_descriptor: interface %u \n", i);
#endif
		if (conf_desc->interface == NULL) {
			// this shouldn't happen
			printf("conf_des->interface == NULL");
			continue;
		}
		usb_intObj = env->NewObject(usb_intClazz, usb_intMid);
		if (!usb_intObj) {
			setLibusbJavaError("shared library error: Error NewObject (usb_intObj)");
			return NULL;
		}
		env->SetObjectArrayElement(usb_intObjArray, i, usb_intObj);
		env->SetIntField(usb_intObj, usb_intFID_num_altsetting, conf_desc->interface[i].num_altsetting);
		// interface descriptor
		usb_intDescObjArray = (jobjectArray) env->NewObjectArray(conf_desc->interface[i].num_altsetting, usb_intDescClazz, NULL);
		if (!usb_intDescObjArray) {
			setLibusbJavaError("shared library error: Error NewObjectArray (usb_intDescObjArray)");
			return NULL;
		}
		for (a = 0; a < conf_desc->interface[i].num_altsetting; a++) {
#ifdef DEBUGON
			printf("\t\t\t\tlibusb_get__activ_config_descriptor: interface descriptor %u \n", a);
#endif

			if (conf_desc->interface[i].altsetting == NULL) {
				// this shouldn't happen
				printf("LibusbJava: libusb_get__activ_config_descriptor: altsetting == NULL\n");
				continue;
			}
			usb_intDescObj = env->NewObject(usb_intDescClazz, usb_intDescMid);
			if (!usb_intDescObj) {
				setLibusbJavaError("shared library error: Error NewObject (usb_intDescObj)");
				return NULL;
			}
			env->SetObjectArrayElement(usb_intDescObjArray, a, usb_intDescObj);
			/*fill fields*/
			env->SetByteField(usb_intDescObj, usb_intDescFID_bLength, conf_desc->interface[i].altsetting[a].bLength);
			env->SetByteField(usb_intDescObj, usb_intDescFID_bDescriptorType, conf_desc->interface[i].altsetting[a].bDescriptorType);
			env->SetByteField(usb_intDescObj, usb_intDescFID_bInterfaceNumber, conf_desc->interface[i].altsetting[a].bInterfaceNumber);
			env->SetByteField(usb_intDescObj, usb_intDescFID_bAlternateSetting, conf_desc->interface[i].altsetting[a].bAlternateSetting);
			env->SetByteField(usb_intDescObj, usb_intDescFID_bNumEndpoints, conf_desc->interface[i].altsetting[a].bNumEndpoints);
			env->SetByteField(usb_intDescObj, usb_intDescFID_bInterfaceClass, conf_desc->interface[i].altsetting[a].bInterfaceClass);
			env->SetByteField(usb_intDescObj, usb_intDescFID_bInterfaceSubClass, conf_desc->interface[i].altsetting[a].bInterfaceSubClass);
			env->SetByteField(usb_intDescObj, usb_intDescFID_bInterfaceProtocol, conf_desc->interface[i].altsetting[a].bInterfaceProtocol);
			env->SetByteField(usb_intDescObj, usb_intDescFID_iInterface, conf_desc->interface[i].altsetting[a].iInterface);
			env->SetIntField(usb_intDescObj, usb_intDescFID_extralen, conf_desc->interface[i].altsetting[a].extra_length);
			if (conf_desc->interface[i].altsetting[a].extra) {
				jbyteArray jbExtraDesc = to_byteArray(env, conf_desc->interface[i].altsetting[a].extra, conf_desc->interface[i].altsetting[a].extra_length);
				env->SetObjectField(usb_intDescObj, usb_intDescFID_extra, jbExtraDesc);
			} else {
				env->SetObjectField(usb_intDescObj, usb_intDescFID_extra, NULL);
			}
			/*endpoint descriptor*/
			usb_epDescObjArray = (jobjectArray) env->NewObjectArray(conf_desc->interface[i].altsetting[a].bNumEndpoints, usb_epDescClazz, NULL);
			if (!usb_epDescObjArray) {
				setLibusbJavaError("shared library error: Error NewObjectArray (usb_epDescObjArray)");
				return NULL;
			}
			for (e = 0; e < conf_desc->interface[i].altsetting[a].bNumEndpoints; e++) {
#ifdef DEBUGON
				printf("\t\t\t\t\tLibusb_get__activ_config_descriptor: endpoint descriptor %u \n",	e);
#endif
				if (conf_desc->interface[i].altsetting[a].endpoint == NULL) {
					printf("LibusbJava: usb_get__activ_config_descriptor: endpoint == NULL\n");
					return usb_confDescObj;
				}
				usb_epDescObj = env->NewObject(usb_epDescClazz, usb_epDescMid);
				if (!usb_epDescObj) {
					setLibusbJavaError("shared library error: Error NewObject (usb_epDescObj)");
					return NULL;
				}
				env->SetObjectArrayElement(usb_epDescObjArray, e, usb_epDescObj);
				env->SetByteField(usb_epDescObj, usb_epDescFID_bLength, conf_desc->interface[i].altsetting[a].endpoint[e].bLength);
				env->SetByteField(usb_epDescObj, usb_epDescFID_bDescriptorType, conf_desc->interface[i].altsetting[a].endpoint[e].bDescriptorType);
				env->SetByteField(usb_epDescObj, usb_epDescFID_bEndpointAddress, conf_desc->interface[i].altsetting[a].endpoint[e].bEndpointAddress);
				env->SetByteField(usb_epDescObj, usb_epDescFID_bmAttributes, conf_desc->interface[i].altsetting[a].endpoint[e].bmAttributes);
				env->SetShortField(usb_epDescObj, usb_epDescFID_wMaxPacketSize, conf_desc->interface[i].altsetting[a].endpoint[e].wMaxPacketSize);
				env->SetByteField(usb_epDescObj, usb_epDescFID_bInterval, conf_desc->interface[i].altsetting[a].endpoint[e].bInterval);
				env->SetByteField(usb_epDescObj, usb_epDescFID_bRefresh, conf_desc->interface[i].altsetting[a].endpoint[e].bRefresh);
				env->SetByteField(usb_epDescObj, usb_epDescFID_bSynchAddress, conf_desc->interface[i].altsetting[a].endpoint[e].bSynchAddress);
				env->SetIntField(usb_epDescObj, usb_epDescFID_extralen, conf_desc->interface[i].altsetting[a].endpoint[e].extra_length);
				if (conf_desc->interface[i].altsetting[a].endpoint[e].extra) {
					jbyteArray jbExtraDesc = to_byteArray(env, conf_desc->interface[i].altsetting[a].endpoint[e].extra, conf_desc->interface[i].altsetting[a].endpoint[e].extra_length);
					env->SetObjectField(usb_epDescObj, usb_epDescFID_extra, jbExtraDesc);
				} else {
					env->SetObjectField(usb_epDescObj, usb_epDescFID_extra, NULL);
				}
			}
			env->SetObjectField(usb_intDescObj, usb_intDescFID_endpoint, usb_epDescObjArray);
		}
		env->SetObjectField(usb_intObj, usb_intFID_altsetting, usb_intDescObjArray);
	}
	env->SetObjectField(usb_confDescObj, usb_confDescFID_interface_, usb_intObjArray);
	libusb_free_config_descriptor(conf_desc);

	return usb_confDescObj;
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_get_string_descriptor_ascii
 * Signature: (JSI)Ljava/lang/String;
 ********************************************************************************************/
JNIEXPORT jstring JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1get_1string_1descriptor_1ascii( JNIEnv *env, jclass obj, jlong handle, jshort desc_index, jint length) {
	jstring string;
	int res = 0;
	clearLibusbJavaError();
	unsigned char data[(int)length + 1];

	res = libusb_get_string_descriptor_ascii((libusb_device_handle*) (unsigned long) handle, desc_index, data, (int)length);

	if (res >= 0)
	{
		data[res] = '\0';
		string = env->NewStringUTF((const char*)data);
	}
	else
	{
		setLibusbJavaError("get_string_descriptor_ascii: retrieve String failed");
		string = NULL;
		ThrowLibusbError(env, res);
	}
	return string;
}
/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_get_descriptor
 * Signature: (JISI)[B
 ********************************************************************************************/

JNIEXPORT jbyteArray JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1get_1descriptor(
		JNIEnv *env, jclass obj, jlong handle, jint desc_type,
		jshort desc_index, jint size) {

	clearLibusbJavaError();
	int res;
	unsigned char data[255];

	res = libusb_get_descriptor((libusb_device_handle*) (unsigned long) handle,	desc_type, desc_index, data, size);
	if (res < 0) {
		setLibusbJavaError("libusb_get_descriptor: retrieve data failed");
		ThrowLibusbError(env, res);
		return NULL;
	}

	return to_byteArray(env, data, res);
}
/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_get_string_descriptor
 * Signature: (JSII)Ljava/lang/String;
 ********************************************************************************************/
JNIEXPORT jstring
JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1get_1string_1descriptor(JNIEnv *env, jclass obj, jlong handle, jshort desc_index, jint langid, jint size) {
	clearLibusbJavaError();
	int res;
	jstring string;
	unsigned char data[(int)size + 1];

	res = libusb_get_string_descriptor((libusb_device_handle*) (unsigned long) handle, desc_index, langid, data, size);

	if (res >= 0) {
		data[res] = '\0';
		string = env->NewStringUTF((const char*) data);
	} else {
		setLibusbJavaError("get_string_descriptor: retrieve String failed");
		string = NULL;
		ThrowLibusbError(env, res);
	}

	return string;

}
/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_alloc_transfer
 * Signature: (I)J
 ********************************************************************************************/
JNIEXPORT jlong JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1alloc_1transfer( JNIEnv *env, jclass obj, jint iso_packets) {
	clearLibusbJavaError();
	return (jlong) libusb_alloc_transfer(iso_packets);
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_free_transfer
 * Signature: (J)V
 ********************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1free_1transfer( JNIEnv *env, jclass obj, jlong transfernumber) {
	clearLibusbJavaError();
	libusb_free_transfer((libusb_transfer*) (unsigned long) transfernumber);
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_submit_transfer
 * Signature: (J)V
 ********************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1submit_1transfer(JNIEnv *env, jclass obj, jlong transfernumber) {
	clearLibusbJavaError();
	ThrowIfUnsuccessful(env, libusb_submit_transfer((libusb_transfer*) (unsigned long) transfernumber));
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_cancel_transfer
 * Signature: (J)V
 ********************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1cancel_1transfer(JNIEnv *env, jclass obj, jlong transfernumber) {
	clearLibusbJavaError();
	ThrowIfUnsuccessful(env, libusb_cancel_transfer((libusb_transfer*) (unsigned long) transfernumber));
}
/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_control_transfer_get_data
 * Signature: (J)[B
 ********************************************************************************************/
JNIEXPORT jbyteArray JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1control_1transfer_1get_1data(JNIEnv *env, jclass obj, jlong transfernumber) {
	clearLibusbJavaError();
	unsigned char *data;
	libusb_transfer* trans = (libusb_transfer*) (unsigned long) transfernumber;

	if (trans == NULL)
		return NULL;

	data = libusb_control_transfer_get_data(trans);
	return to_byteArray(env, data, trans->actual_length - LIBUSB_CONTROL_SETUP_SIZE );
}

/*********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_control_transfer_get_setup
 * Signature: (J)[B
 ********************************************************************************************/
JNIEXPORT jbyteArray JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1control_1transfer_1get_1setup(JNIEnv *env, jclass obj, jlong transfernumber) {
	clearLibusbJavaError();
	unsigned char *data;
	libusb_transfer* trans = (libusb_transfer*) (unsigned long) transfernumber;

	if (trans == NULL) {
		return NULL;
	}

	data = (unsigned char*)libusb_control_transfer_get_setup(trans);

	return to_byteArray(env, data, 8);
}
/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_fill_control_setup
 * Signature: (IIIII)[B
 ********************************************************************************************/
JNIEXPORT jbyteArray JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1fill_1control_1setup(JNIEnv *env, jclass obj, jint bmRequestType, jint bRequest, jint wValue, jint wIndex, jint wLength) {
	clearLibusbJavaError();
	unsigned char setup[8];

	libusb_fill_control_setup(setup, bmRequestType, bRequest, wValue, wIndex, wLength);

	return to_byteArray(env, setup, 8);
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_fill_control_transfer
 * Signature: (JJ[BI)V
 ********************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1fill_1control_1transfer(JNIEnv *env, jclass obj, jlong transfernumber, jlong handle, jbyteArray buffer, jint timeout) {
	clearLibusbJavaError();
	jbyte *byteArrayElements = env->GetByteArrayElements(buffer, NULL);
	libusb_fill_control_transfer((libusb_transfer*) (unsigned long) transfernumber,(libusb_device_handle*) (unsigned long) handle,(unsigned char*) byteArrayElements, transfer_callback, env,(unsigned int) timeout);
	env->ReleaseByteArrayElements(buffer, byteArrayElements, 0);
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_fill_bulk_transfer
 * Signature: (JJB[BII)V
 ********************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1fill_1bulk_1transfer(JNIEnv *env, jclass obj, jlong transfernumber, jlong handle,	jbyte endpoint, jbyteArray buffer, jint length, jint timeout) {
	clearLibusbJavaError();
	jbyte *byteArrayElements = env->GetByteArrayElements(buffer, NULL);
	libusb_fill_bulk_transfer((libusb_transfer*) (unsigned long) transfernumber,(libusb_device_handle*) (unsigned long) handle, endpoint,(unsigned char*) byteArrayElements, length, transfer_callback, env,(unsigned int) timeout);
	env->ReleaseByteArrayElements(buffer, byteArrayElements, 0);
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_fill_interrupt_transfer
 * Signature: (JJB[BII)V
 ********************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1fill_1interrupt_1transfer(JNIEnv *env, jclass obj, jlong transfernumber, jlong handle,jbyte endpoint, jbyteArray buffer, jint length, jint timeout) {
	clearLibusbJavaError();
	jbyte *byteArrayElements = env->GetByteArrayElements(buffer, NULL);
	libusb_fill_interrupt_transfer((libusb_transfer*) (unsigned long) transfernumber,(libusb_device_handle*) (unsigned long) handle, endpoint,(unsigned char*) byteArrayElements, length, transfer_callback, env, timeout);
	env->ReleaseByteArrayElements(buffer, byteArrayElements, 0);
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_fill_iso_transfer
 * Signature: (JJB[BIII)V
 ********************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1fill_1iso_1transfer(JNIEnv *env, jclass obj, jlong transfernumber, jlong handle, jbyte endpoint, jbyteArray buffer, jint length, jint num_iso_packets, jint timeout) {
	clearLibusbJavaError();
	jbyte *byteArrayElements = env->GetByteArrayElements(buffer, NULL);
	libusb_fill_iso_transfer((libusb_transfer*) (unsigned long) transfernumber,	(libusb_device_handle*) (unsigned long) handle, endpoint, (unsigned char*) byteArrayElements, length, num_iso_packets,	transfer_callback, env, timeout);
	env->ReleaseByteArrayElements(buffer, byteArrayElements, 0);
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_set_iso_packet_lengths
 * Signature: (JI)V
 ********************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1set_1iso_1packet_1lengths(JNIEnv *env, jclass obj, jlong transfernumber, jint length) {
	clearLibusbJavaError();
	libusb_set_iso_packet_lengths((libusb_transfer*) (unsigned long) transfernumber, length);
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_get_iso_packet_buffer
 * Signature: (JI)[B
 ********************************************************************************************/

JNIEXPORT jbyteArray JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1get_1iso_1packet_1buffer(JNIEnv *env, jclass obj, jlong transfernumber, jint packet) {
	clearLibusbJavaError();
	int size = 0;
	unsigned char *data = NULL;
	libusb_transfer* transfer =	(libusb_transfer*) (unsigned long) transfernumber;

	if (transfer == NULL) {
		setLibusbJavaError("libusb_get_iso_packet_buffer: ilegal transfernumber");
		return NULL;
	}

	if (packet < transfer->num_iso_packets) {
		size = transfer->iso_packet_desc[packet].actual_length;
	}

	data = libusb_get_iso_packet_buffer((libusb_transfer*) (unsigned long) transfernumber, packet);
	if (data == NULL) {
		setLibusbJavaError("libusb_get_iso_packet_buffer: packet does not exist");
		return NULL;
	}

	return to_byteArray(env, data, size);
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_get_iso_packet_buffer_simple
 * Signature: (JI)[B
 ********************************************************************************************/
JNIEXPORT jbyteArray JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1get_1iso_1packet_1buffer_1simple(JNIEnv *env, jclass obj, jlong transfernumber, jint packet) {
	clearLibusbJavaError();
	int size = 0;
	unsigned char *data = NULL;
	libusb_transfer* transfer =	(libusb_transfer*) (unsigned long) transfernumber;

	if (transfer == NULL) {
		setLibusbJavaError("libusb_get_iso_packet_buffer_simple: ilegal transfernumber");
		return NULL;
	}

	if (packet < transfer->num_iso_packets) {
		size = transfer->iso_packet_desc[packet].actual_length;
	}

	data = libusb_get_iso_packet_buffer_simple((libusb_transfer*) (unsigned long) transfernumber, packet);

	if (data == NULL) {
		setLibusbJavaError("libusb_get_iso_packet_buffer_simple: packet does not exist");
		return NULL;
	}

	return to_byteArray(env, data, size);
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_try_lock_events
 * Signature: (J)I
 ********************************************************************************************/
JNIEXPORT jint JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1try_1lock_1events(JNIEnv *env, jclass obj, jlong ctx) {
	clearLibusbJavaError();
	return libusb_try_lock_events((libusb_context*) (unsigned long) ctx);
//	return libusb_try_lock_events(NULL);
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_lock_events
 * Signature: (J)V
 ********************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1lock_1events(JNIEnv *env, jclass obj, jlong ctx) {
	libusb_lock_events((libusb_context*) (unsigned long) ctx);
//	libusb_lock_events(NULL);
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_unlock_events
 * Signature: (J)V
 ********************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1unlock_1events(JNIEnv *env, jclass obj, jlong ctx) {
	clearLibusbJavaError();
	libusb_unlock_events((libusb_context*) (unsigned long) ctx);
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_event_handling_ok
 * Signature: (J)I
 ********************************************************************************************/
JNIEXPORT jint JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1event_1handling_1ok(JNIEnv *env, jclass obj, jlong ctx) {
	clearLibusbJavaError();
	return libusb_event_handling_ok((libusb_context*) (unsigned long) ctx);
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_event_handler_active
 * Signature: (J)I
 ********************************************************************************************/
JNIEXPORT jint JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1event_1handler_1active(JNIEnv *env, jclass obj, jlong ctx) {
	clearLibusbJavaError();
	return libusb_event_handler_active((libusb_context*) (unsigned long) ctx);
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_lock_event_waiters
 * Signature: (J)V
 ********************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1lock_1event_1waiters(JNIEnv *env, jclass obj, jlong ctx) {
	clearLibusbJavaError();
	libusb_lock_event_waiters((libusb_context*) (unsigned long) ctx);
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_unlock_event_waiters
 * Signature: (J)V
 ********************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1unlock_1event_1waiters(JNIEnv *env, jclass obj, jlong ctx) {
	clearLibusbJavaError();
	libusb_unlock_event_waiters((libusb_context*) (unsigned long) ctx);
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_wait_for_event
 * Signature: (JJ)I
 ********************************************************************************************/
JNIEXPORT jint JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1wait_1for_1event(JNIEnv *env, jclass obj, jlong ctx, jlong timevalue) {
	clearLibusbJavaError();
	if (timevalue) {
		timeval tv;
		tv.tv_sec = timevalue;
		tv.tv_usec = 0;
		return libusb_wait_for_event((libusb_context*) (unsigned long) ctx, &tv);
	}
	return libusb_wait_for_event((libusb_context*) (unsigned long) ctx, NULL);
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_handle_events_timeout
 * Signature: (JJ)V
 ********************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1handle_1events_1timeout(JNIEnv *env, jclass obj, jlong ctx, jlong timevalue) {
	clearLibusbJavaError();
	if (timevalue != 0)
	{
		timeval tv;
		tv.tv_sec = timevalue;
		tv.tv_usec = 0;
		ThrowIfUnsuccessful(env, libusb_handle_events_timeout((libusb_context*) (unsigned long) ctx, &tv));
	}
	else
	{
		ThrowIfUnsuccessful(env, libusb_handle_events_timeout((libusb_context*) (unsigned long) ctx, NULL));
	}
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_handle_events
 * Signature: (J)V
 ********************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1handle_1events(JNIEnv *env, jclass obj, jlong ctx) {
	clearLibusbJavaError();
	ThrowIfUnsuccessful(env, libusb_handle_events((libusb_context*) (unsigned long) ctx));
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_handle_events_locked
 * Signature: (JJ)V
 ********************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1handle_1events_1locked(JNIEnv *env, jclass obj, jlong ctx, jlong timevalue) {
	clearLibusbJavaError();
	if (timevalue) {
		timeval tv;
		tv.tv_sec = timevalue;
		tv.tv_usec = 0;
		ThrowIfUnsuccessful(env, libusb_handle_events_locked((libusb_context*) (unsigned long) ctx, &tv));
	}
	else
	{
		ThrowIfUnsuccessful(env, libusb_handle_events_locked((libusb_context*) (unsigned long) ctx, NULL));
	}
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_pollfds_handle_timeouts
 * Signature: (J)I
 ********************************************************************************************/
JNIEXPORT jint JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1pollfds_1handle_1timeouts(JNIEnv *env, jclass obj, jlong ctx) {
	clearLibusbJavaError();
	return libusb_pollfds_handle_timeouts((libusb_context*) (unsigned long) ctx);
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_get_next_timeout
 * Signature: (J)I
 ********************************************************************************************/
JNIEXPORT jint JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1get_1next_1timeout(JNIEnv *env, jclass obj, jlong ctx) {
	clearLibusbJavaError();
	int res;
	timeval tv;

	/*!	\todo	Is this code working correctly if we use it in a 64-Bit environment? Actually
	 * 			it's unlikely to have a timeout of more than 2^(31)-1 seconds. But it is a
	 * 			possible value. */
	res = libusb_get_next_timeout((libusb_context*) (unsigned long) ctx, &tv);

	if (res > 0)
	{
		res = tv.tv_sec;
	}
	else if (res == 0) {
		res = -1;
	}
	else
	{
		ThrowLibusbError(env, res);
		res = -2;
	}

	return res;
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_set_pollfd_notifiers
 * Signature: (JZ)V
 ********************************************************************************************/
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1set_1pollfd_1notifiers(JNIEnv *env, jclass obj, jlong ctx, jboolean remove) {
	clearLibusbJavaError();
	if (remove)
	{
		libusb_set_pollfd_notifiers((libusb_context*) (unsigned long) ctx, NULL, NULL, env);
	}
	else
	{
		libusb_set_pollfd_notifiers((libusb_context*) (unsigned long) ctx, fd_added_callback, fd_removed_callback, env);
	}
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_get_pollfds
 * Signature: (J)[Lch/ntb/inf/libusbJava/Libusb_pollfd;
 ********************************************************************************************/
JNIEXPORT jobjectArray JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1get_1pollfds(JNIEnv *env, jclass obj, jlong ctx) {
	clearLibusbJavaError();
	int count = 0;
	jobjectArray pollfdArray;
	jobject pollfdObj;
	const libusb_pollfd **fdList;

	fdList = libusb_get_pollfds((libusb_context*) (unsigned long) ctx);
	if (fdList == NULL) {
		return NULL;
	}
	/*determine the length of the list*/
	while (fdList[count]) {
		count++;
	}
	pollfdArray = (jobjectArray) env->NewObjectArray(count, usb_pollfd_clazz, NULL);
	if (!pollfdArray) {
		setLibusbJavaError("libusb_get_pollfds: error NewObjectArry (pollfdArray");
		return NULL;
	}

	for (int i = 0; i < count; i++) {
		pollfdObj = env->NewObject(usb_pollfd_clazz, usb_pollfd_Mid);
		if (!pollfdObj) {
			setLibusbJavaError("libusb_get_pollfds: Error NewObject (pollfdObj)");
			return NULL;
		}
		env->SetObjectArrayElement(pollfdArray, i, pollfdObj);
		env->SetIntField(pollfdObj, usb_pollfdFID_fd, fdList[i]->fd);
		env->SetShortField(pollfdObj, usb_pollfdFID_events, fdList[i]->events);
	}
	return pollfdArray;
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_control_transfer
 * Signature: (JIIII[BII)I
 ********************************************************************************************/
JNIEXPORT jint JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1control_1transfer(JNIEnv *env, jclass obj, jlong handle, jint bmRequestType, jint bRequest, jint wValue, jint wIndex, jbyteArray buffer, jint wLength, jint timeout) {
	clearLibusbJavaError();
	int res;
	unsigned char* data;
	data = (unsigned char*) env->GetByteArrayElements(buffer, NULL);
	res = libusb_control_transfer((libusb_device_handle*) (unsigned long) handle, bmRequestType, bRequest, wValue, wIndex, data, wLength, timeout);
	env->ReleaseByteArrayElements(buffer, (jbyte*) data, 0);

	return res;
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_bulk_transfer
 * Signature: (JB[BII)I
 ********************************************************************************************/
JNIEXPORT jint JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1bulk_1transfer(JNIEnv *env, jclass obj, jlong handle, jbyte endpoint, jbyteArray buffer, jint length, jint timeout) {
	clearLibusbJavaError();
	int libusb_result = 0;
	int bytes_transferred = 0;
	unsigned char* data = (unsigned char*) env->GetByteArrayElements(buffer, NULL);

	libusb_result = libusb_bulk_transfer((libusb_device_handle*) (unsigned long) handle,	endpoint, data, length, &bytes_transferred, timeout);
	env->ReleaseByteArrayElements(buffer, (jbyte*) data, 0);

	if (libusb_result != 0)
	{
		ThrowLibusbError(env, libusb_result);
		bytes_transferred = 0;
	}

	return bytes_transferred;
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_interrupt_transfer
 * Signature: (JB[BII)I
 ********************************************************************************************/
JNIEXPORT jint JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1interrupt_1transfer(JNIEnv *env, jclass obj, jlong handle, jbyte endpoint, jbyteArray buffer, jint length, jint timeout) {
	clearLibusbJavaError();
	int libusb_result;
	int bytes_transferred = 0;
	unsigned char* data = (unsigned char*) env->GetByteArrayElements(buffer, NULL);
	libusb_result = libusb_interrupt_transfer((libusb_device_handle*) (unsigned long) handle, endpoint, data,	length, &bytes_transferred, timeout);
	env->ReleaseByteArrayElements(buffer, (jbyte*) data, 0);

	if (libusb_result != 0)
	{
		ThrowLibusbError(env, libusb_result);
		bytes_transferred = 0;
	}

	return bytes_transferred;
}

/********************************************************************************************
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_strerror
 * Signature: ()Ljava/lang/String;
 ********************************************************************************************/
JNIEXPORT jstring JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1strerror(JNIEnv *env, jclass obj) {
	char *str = "Libusb-1.0 Error";

	/* check for LibusbJava specific errors first*/
	if (libusbJavaError != NULL) {
		str = libusbJavaError;
		clearLibusbJavaError();
	}

	return env->NewStringUTF(str);
}

/*
 * Class:     ch_ntb_inf_libusbJava_LibusbJava1
 * Method:    libusb_exceptionTest
 * Signature: (I)V
 */
JNIEXPORT void JNICALL Java_ch_ntb_inf_libusbJava_LibusbJava1_libusb_1exceptionTest(JNIEnv *env, jclass obj, jint code)
{
	ThrowLibusbError(env, code);
}

/********************************************************************************************
 * Class:     LibusbJava_1_0.cpp
 * Method:    transfer_callback
 *
 ********************************************************************************************/
static void LIBUSB_CALL transfer_callback(struct libusb_transfer *transfer) {

	((JNIEnv*) transfer->user_data)->CallVoidMethod(usb_cb_clazz,
			usb_transfer_cb_Mid);
}

/********************************************************************************************
 * Class:     LibusbJava_1_0.cpp
 * Method:    fd_added_callback
 *
 ********************************************************************************************/
static void LIBUSB_CALL fd_added_callback(int fd, short events, void *user_data) {

	((JNIEnv*) user_data)->CallVoidMethod(usb_cb_clazz, usb_fd_added_cb_Mid,
			(jint) fd);
}

/********************************************************************************************
 * Class:     LibusbJava_1_0.cpp
 * Method:    fd_removed_callback
 *
 ********************************************************************************************/
static void LIBUSB_CALL fd_removed_callback(int fd, void *user_data) {

	((JNIEnv*) user_data)->CallVoidMethod(usb_cb_clazz, usb_fd_removed_cb_Mid,
			(jint) fd);
}

/*!	\brief Turns a memory section into a java byte array that can be returned to the java
 *         environment.
 *
 *	\param	env		Environment to create the array for
 *	\param 	data	Pointer to the data to be put in the array
 *	\param	len		[bytes] Length of the data to be put into the array
 *
 *	\return	The pointer to the newly created byte array. NULL if an error occured
 *
 *	\note	If NULL is returned, #libusbJavaError is set to a matching error string.
 */
static __inline jbyteArray JNICALL to_byteArray(JNIEnv *env, const void *data, size_t len)
{
	jbyteArray result = env->NewByteArray(len);

	if (result != NULL) {
		/* Using SetByteArrayRegion, we avoid that the JNI layer first copies the data already
		 * available in the array in our space just to overwrite them. As we just allocated the
		 * byte aray with a length of "len", the set operation can never fail. The check for an
		 * exception can be omitted. */
		env->SetByteArrayRegion(result, 0, len, (const signed char *)data);
#if 0 /* No need to check for exceptions here... */
		if (env->ExceptionOccurred()){
			setLibusbJavaError("to_byteArray: unable to copy data to array");
			env->DeleteLocalRef(result);
			result = NULL;
		}
#endif
	}
	else {
		setLibusbJavaError("to_byteArray: out of memory");
	}

	return result;
}

/*!	\brief	Convenience function that throws an exception in the callers environment if
 *         	the given result is not "success"
 *
 *			This function can be used to wrap calls to the libusb if no further reaction
 *			on a unsuccessful result is needed, than throwing an exception in the java
 *			environment.
 *
 *	\param	env				Java environment of the caller
 *	\param 	libusb_result	Result code of the libusb call
 */
static __inline void JNICALL ThrowIfUnsuccessful(JNIEnv *env, int libusb_result)
{
	if (libusb_result != 0)
	{
		ThrowLibusbError(env, libusb_result);
	}
}

/*!	\brief Throws an exception of type LibusbError in the calling Java environment.
 *
 * 	\param	env		Environment to throw the exception in
 * 	\param	code	Error code that represents the cause of the exception
 */
static __inline void JNICALL ThrowLibusbError(JNIEnv *env, jint code)
{
    jmethodID constructor = NULL;
    jthrowable exception = NULL;

    jclass clazz = env->FindClass("ch/ntb/inf/libusbJava/exceptions/LibusbError");
    if (clazz == NULL)
    {
    	goto no_class;
    }

    constructor = env->GetMethodID(clazz, "<init>", "(I)V");
	if (constructor == NULL)
	{
		goto no_constructor;
	}

	exception = (jthrowable)env->NewObject(clazz, constructor, code);
	if (exception == NULL)
	{
		goto no_object;
	}

	if (env->Throw(exception) != 0)
	{
		goto throw_failed;
	}

	env->DeleteLocalRef(exception);
	env->DeleteLocalRef(clazz);

	return;

/* Error Handling. All errors covered here are caused by JNI callbacks and have 
 * therefore already thrown appropriate exceptions in the Java environment.
 * Therefore we only have to cleanup what we constructed. */
throw_failed:
	env->DeleteLocalRef(exception);

no_object:

no_constructor:
	env->DeleteLocalRef(clazz);

no_class:

	return;
}