From 1870e3694d5ce0a892c839b82520ac00f3ea55f8 Mon Sep 17 00:00:00 2001 From: meri Date: Mon, 30 Apr 2007 18:39:18 +0000 Subject: [PATCH] added win32 support for MINGW32-compiler/cross-compiler git-svn-id: https://svn.gnumonks.org/trunk/librfid@1989 e0336214-984f-0b4b-a45f-81c69e1f0ede --- Makefile.am | 10 +- autogen.sh | 1 - configure.in | 13 +- include/librfid/rfid.h | 16 +- include/librfid/rfid_asic_rc632.h | 2 +- include/librfid/rfid_layer2.h | 1 - src/Makefile.am | 18 +- src/libusb_dyn.c | 484 ++++++++++++++++++++++++++++++ src/libusb_dyn.h | 394 ++++++++++++++++++++++++ src/rfid.c | 3 + src/rfid_access_mifare_classic.c | 2 - src/rfid_asic_rc632.c | 6 +- src/rfid_reader_openpcd.c | 5 + src/usleep.c | 30 ++ src/usleep.h | 6 + utils/Makefile.am | 11 +- utils/common.c | 2 +- utils/librfid-tool.c | 16 +- utils/mifare-tool.c | 7 +- 19 files changed, 996 insertions(+), 31 deletions(-) create mode 100644 src/libusb_dyn.c create mode 100644 src/libusb_dyn.h create mode 100644 src/usleep.c create mode 100644 src/usleep.h diff --git a/Makefile.am b/Makefile.am index 5ba35ad..c546dcf 100644 --- a/Makefile.am +++ b/Makefile.am @@ -1,9 +1,15 @@ AUTOMAKE_OPTIONS = foreign dist-bzip2 1.6 SUBDIRS = etc include src utils -LINKOPTS = -lusb -AM_CFLAGS = -std=gnu99 +DEFAULT_AM_CFLAGS = -std=gnu99 +if ENABLE_WIN32 +LINKOPTS = -mno-cygwin +AM_CFLAGS = $(DEFAULT_AM_CFLAGS) +else +LINKOPTS = -lusb +AM_CFLAGS = $(DEFAULT_AM_CFLAGS) -mno-cygwin +endif EXTRA_DIST = LICENSING librfid.spec openct-cm5121-librfid.patch diff --git a/autogen.sh b/autogen.sh index ccce4f0..990e162 100755 --- a/autogen.sh +++ b/autogen.sh @@ -12,7 +12,6 @@ run () } run aclocal -#run autoheader run libtoolize -f run automake -a run autoconf diff --git a/configure.in b/configure.in index da52275..2411992 100644 --- a/configure.in +++ b/configure.in @@ -3,7 +3,6 @@ dnl Process this file with autoconf to create configure. AC_INIT AC_CANONICAL_SYSTEM - AM_INIT_AUTOMAKE(librfid, 0.1.0) AC_PROG_CC @@ -11,6 +10,17 @@ AC_EXEEXT AM_PROG_LIBTOOL AC_SUBST(LIBTOOL_DEPS) +AC_MSG_CHECKING([for build environment]) +case "$target_alias" in +*-mingw*) BUILDENV=WIN32;; +*-cygwin*) BUILDENV=WIN32;; +*) BUILDENV=UNIX;; +esac +AC_MSG_RESULT($BUILDENV) +AC_SUBST(BUILDENV) +AM_CONDITIONAL(ENABLE_WIN32, test "$BUILDENV" == "WIN32") +AM_CONDITIONAL(DISABLE_WIN32, test "$BUILDENV" != "WIN32") + AC_ARG_ENABLE(ccid, [ --enable-ccid Include internal CCID driver for CM5121], [MY_CCID=1], [MY_CCID=0]) @@ -52,7 +62,6 @@ AC_ARG_ENABLE(firmware, AM_CONDITIONAL(ENABLE_FIRMWARE, test "$ENABLE_FIRMWARE" == "1") AC_ARG_WITH() -#AC_CHECK_HEADERS(usb.h, [have_libusb="yes"], [ AC_MSG_WARN([usb.h not found, use --enable-libusb=PATH. Otherwise, INDI will compile without Apogee USB support.]) ]) AC_CHECK_LIB(usb, usb_close,,) AM_CONDITIONAL(HAVE_LIBUSB, test "x$have_libusb" = "xyes") diff --git a/include/librfid/rfid.h b/include/librfid/rfid.h index 187e884..580cc09 100644 --- a/include/librfid/rfid.h +++ b/include/librfid/rfid.h @@ -1,14 +1,22 @@ #ifndef _RFID_H #define _RFID_H -#include +#include +#include -#ifdef __LIBRFID__ +#ifdef __MINGW32__ +#define ENOTSUP 100 +#define ETIMEDOUT 101 +typedef unsigned char u_int8_t; +typedef unsigned short u_int16_t; +typedef unsigned long u_int32_t; +typedef unsigned long long u_int64_t; +#endif/*__MINGW32__*/ + +#ifdef __LIBRFID__ #include -//#define DEBUG_LIBRFID - #ifdef DEBUG_LIBRFID #ifdef LIBRFID_FIRMWARE diff --git a/include/librfid/rfid_asic_rc632.h b/include/librfid/rfid_asic_rc632.h index 4eac82e..3aebd1f 100644 --- a/include/librfid/rfid_asic_rc632.h +++ b/include/librfid/rfid_asic_rc632.h @@ -3,7 +3,7 @@ struct rfid_asic_transport_handle; -#include +#include #include struct rfid_asic_rc632_transport { diff --git a/include/librfid/rfid_layer2.h b/include/librfid/rfid_layer2.h index dcd05e4..84d4579 100644 --- a/include/librfid/rfid_layer2.h +++ b/include/librfid/rfid_layer2.h @@ -1,7 +1,6 @@ #ifndef _RFID_LAYER2_H #define _RFID_LAYER2_H -#include #include struct rfid_layer2_handle; diff --git a/src/Makefile.am b/src/Makefile.am index 7c87dde..13f7a85 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -9,7 +9,7 @@ if ENABLE_STATIC AM_CFLAGS_STATIC = -DLIBRFID_STATIC endif -noinst_HEADERS=rfid_iso14443_common.h rc632.h +noinst_HEADERS=rfid_iso14443_common.h rc632.h libusb_dyn.h usleep.h CORE=rfid.c rfid_layer2.c rfid_protocol.c rfid_reader.c rfid_scan.c L2=rfid_layer2_iso14443a.c rfid_layer2_iso14443b.c rfid_layer2_iso15693.c rfid_iso14443_common.c @@ -18,6 +18,12 @@ ASIC=rfid_asic_rc632.c READER=rfid_reader_openpcd.c MISC=rfid_access_mifare_classic.c +if ENABLE_WIN32 +WIN32=usleep.c libusb_dyn.c +AM_LDLAGS_WIN32=-mno-cygwin -lwinmm +AM_CFLAGS_WIN32=-mno-cygwin +endif + if ENABLE_CCID READER_CM5121=rfid_reader_cm5121.c ccid/rfid_reader_cm5121_ccid_direct.c ccid/ccid-driver.c AM_CFLAGS_CM5121= -DENABLE_CM5121 @@ -31,12 +37,16 @@ endif INCLUDES = $(all_includes) -I$(top_srcdir)/include $(INCLUDES_FIRMWARE) \ $(INCLUDES_STATIC) @OPENCT_CFLAGS@ AM_CFLAGS = -std=gnu99 -D__LIBRFID__ $(AM_CFLAGS_FIRMWARE) $(AM_CFLAGS_STATIC) \ - $(AM_CFLAGS_CM5121) + $(AM_CFLAGS_CM5121) $(AM_CFLAGS_WIN32) lib_LTLIBRARIES = librfid.la -librfid_la_LDFLAGS = -Wc,-nostartfiles -version-info $(LIBVERSION) @OPENCT_LIBS@ +librfid_la_LDFLAGS = -Wc,-nostartfiles -version-info $(LIBVERSION) $(AM_LDFLAGS_WIN32) @OPENCT_LIBS@ librfid_la_SOURCES = $(CORE) $(L2) $(PROTO) $(ASIC) $(MISC) \ - $(READER) $(READER_CM5121) + $(READER) $(READER_CM5121) $(WIN32) + +if ENABLE_WIN32 +librfid_la_LIBADD = -lwinmm +endif pkgconfigdir = $(libdir)/pkgconfig pkgconfig_DATA = librfid.pc diff --git a/src/libusb_dyn.c b/src/libusb_dyn.c new file mode 100644 index 0000000..78acc49 --- /dev/null +++ b/src/libusb_dyn.c @@ -0,0 +1,484 @@ +/* LIBUSB-WIN32, Generic Windows USB Library + * Copyright (c) 2002-2005 Stephan Meyer + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#include +#include + +#include "libusb_dyn.h" + +#define LIBUSB_DLL_NAME "libusb0.dll" + +typedef usb_dev_handle * (*usb_open_t)(struct usb_device *dev); +typedef int (*usb_close_t)(usb_dev_handle *dev); +typedef int (*usb_get_string_t)(usb_dev_handle *dev, int index, int langid, + char *buf, size_t buflen); +typedef int (*usb_get_string_simple_t)(usb_dev_handle *dev, int index, + char *buf, size_t buflen); +typedef int (*usb_get_descriptor_by_endpoint_t)(usb_dev_handle *udev, int ep, + unsigned char type, + unsigned char index, + void *buf, int size); +typedef int (*usb_get_descriptor_t)(usb_dev_handle *udev, unsigned char type, + unsigned char index, void *buf, int size); +typedef int (*usb_bulk_write_t)(usb_dev_handle *dev, int ep, char *bytes, + int size, int timeout); +typedef int (*usb_bulk_read_t)(usb_dev_handle *dev, int ep, char *bytes, + int size, int timeout); +typedef int (*usb_interrupt_write_t)(usb_dev_handle *dev, int ep, char *bytes, + int size, int timeout); +typedef int (*usb_interrupt_read_t)(usb_dev_handle *dev, int ep, char *bytes, + int size, int timeout); +typedef int (*usb_control_msg_t)(usb_dev_handle *dev, int requesttype, + int request, int value, int index, + char *bytes, int size, int timeout); +typedef int (*usb_set_configuration_t)(usb_dev_handle *dev, int configuration); +typedef int (*usb_claim_interface_t)(usb_dev_handle *dev, int interface); +typedef int (*usb_release_interface_t)(usb_dev_handle *dev, int interface); +typedef int (*usb_set_altinterface_t)(usb_dev_handle *dev, int alternate); +typedef int (*usb_resetep_t)(usb_dev_handle *dev, unsigned int ep); +typedef int (*usb_clear_halt_t)(usb_dev_handle *dev, unsigned int ep); +typedef int (*usb_reset_t)(usb_dev_handle *dev); +typedef char * (*usb_strerror_t)(void); +typedef void (*usb_init_t)(void); +typedef void (*usb_set_debug_t)(int level); +typedef int (*usb_find_busses_t)(void); +typedef int (*usb_find_devices_t)(void); +typedef struct usb_device * (*usb_device_t)(usb_dev_handle *dev); +typedef struct usb_bus * (*usb_get_busses_t)(void); +typedef int (*usb_install_service_np_t)(void); +typedef int (*usb_uninstall_service_np_t)(void); +typedef int (*usb_install_driver_np_t)(const char *inf_file); +typedef const struct usb_version * (*usb_get_version_t)(void); +typedef int (*usb_isochronous_setup_async_t)(usb_dev_handle *dev, + void **context, + unsigned char ep, int pktsize); +typedef int (*usb_bulk_setup_async_t)(usb_dev_handle *dev, void **context, + unsigned char ep); +typedef int (*usb_interrupt_setup_async_t)(usb_dev_handle *dev, void **context, + unsigned char ep); +typedef int (*usb_submit_async_t)(void *context, char *bytes, int size); +typedef int (*usb_reap_async_t)(void *context, int timeout); +typedef int (*usb_free_async_t)(void **context); + + +static usb_open_t _usb_open = NULL; +static usb_close_t _usb_close = NULL; +static usb_get_string_t _usb_get_string = NULL; +static usb_get_string_simple_t _usb_get_string_simple = NULL; +static usb_get_descriptor_by_endpoint_t _usb_get_descriptor_by_endpoint = NULL; +static usb_get_descriptor_t _usb_get_descriptor = NULL; +static usb_bulk_write_t _usb_bulk_write = NULL; +static usb_bulk_read_t _usb_bulk_read = NULL; +static usb_interrupt_write_t _usb_interrupt_write = NULL; +static usb_interrupt_read_t _usb_interrupt_read = NULL; +static usb_control_msg_t _usb_control_msg = NULL; +static usb_set_configuration_t _usb_set_configuration = NULL; +static usb_claim_interface_t _usb_claim_interface = NULL; +static usb_release_interface_t _usb_release_interface = NULL; +static usb_set_altinterface_t _usb_set_altinterface = NULL; +static usb_resetep_t _usb_resetep = NULL; +static usb_clear_halt_t _usb_clear_halt = NULL; +static usb_reset_t _usb_reset = NULL; +static usb_strerror_t _usb_strerror = NULL; +static usb_init_t _usb_init = NULL; +static usb_set_debug_t _usb_set_debug = NULL; +static usb_find_busses_t _usb_find_busses = NULL; +static usb_find_devices_t _usb_find_devices = NULL; +static usb_device_t _usb_device = NULL; +static usb_get_busses_t _usb_get_busses = NULL; +static usb_install_service_np_t _usb_install_service_np = NULL; +static usb_uninstall_service_np_t _usb_uninstall_service_np = NULL; +static usb_install_driver_np_t _usb_install_driver_np = NULL; +static usb_get_version_t _usb_get_version = NULL; +static usb_isochronous_setup_async_t _usb_isochronous_setup_async = NULL; +static usb_bulk_setup_async_t _usb_bulk_setup_async = NULL; +static usb_interrupt_setup_async_t _usb_interrupt_setup_async = NULL; +static usb_submit_async_t _usb_submit_async = NULL; +static usb_reap_async_t _usb_reap_async = NULL; +static usb_free_async_t _usb_free_async = NULL; + + +void usb_init(void) +{ + HINSTANCE libusb_dll = LoadLibrary(LIBUSB_DLL_NAME); + + if(!libusb_dll) + return; + + timeBeginPeriod(1); + + _usb_open = (usb_open_t) + GetProcAddress(libusb_dll, "usb_open"); + _usb_close = (usb_close_t) + GetProcAddress(libusb_dll, "usb_close"); + _usb_get_string = (usb_get_string_t) + GetProcAddress(libusb_dll, "usb_get_string"); + _usb_get_string_simple = (usb_get_string_simple_t) + GetProcAddress(libusb_dll, "usb_get_string_simple"); + _usb_get_descriptor_by_endpoint = (usb_get_descriptor_by_endpoint_t) + GetProcAddress(libusb_dll, "usb_get_descriptor_by_endpoint"); + _usb_get_descriptor = (usb_get_descriptor_t) + GetProcAddress(libusb_dll, "usb_get_descriptor"); + _usb_bulk_write = (usb_bulk_write_t) + GetProcAddress(libusb_dll, "usb_bulk_write"); + _usb_bulk_read = (usb_bulk_read_t) + GetProcAddress(libusb_dll, "usb_bulk_read"); + _usb_interrupt_write = (usb_interrupt_write_t) + GetProcAddress(libusb_dll, "usb_interrupt_write"); + _usb_interrupt_read = (usb_interrupt_read_t) + GetProcAddress(libusb_dll, "usb_interrupt_read"); + _usb_control_msg = (usb_control_msg_t) + GetProcAddress(libusb_dll, "usb_control_msg"); + _usb_set_configuration = (usb_set_configuration_t) + GetProcAddress(libusb_dll, "usb_set_configuration"); + _usb_claim_interface = (usb_claim_interface_t) + GetProcAddress(libusb_dll, "usb_claim_interface"); + _usb_release_interface = (usb_release_interface_t) + GetProcAddress(libusb_dll, "usb_release_interface"); + _usb_set_altinterface = (usb_set_altinterface_t) + GetProcAddress(libusb_dll, "usb_set_altinterface"); + _usb_resetep = (usb_resetep_t) + GetProcAddress(libusb_dll, "usb_resetep"); + _usb_clear_halt = (usb_clear_halt_t) + GetProcAddress(libusb_dll, "usb_clear_halt"); + _usb_reset = (usb_reset_t) + GetProcAddress(libusb_dll, "usb_reset"); + _usb_strerror = (usb_strerror_t) + GetProcAddress(libusb_dll, "usb_strerror"); + _usb_init = (usb_init_t) + GetProcAddress(libusb_dll, "usb_init"); + _usb_set_debug = (usb_set_debug_t) + GetProcAddress(libusb_dll, "usb_set_debug"); + _usb_find_busses = (usb_find_busses_t) + GetProcAddress(libusb_dll, "usb_find_busses"); + _usb_find_devices = (usb_find_devices_t) + GetProcAddress(libusb_dll, "usb_find_devices"); + _usb_device = (usb_device_t) + GetProcAddress(libusb_dll, "usb_device"); + _usb_get_busses = (usb_get_busses_t) + GetProcAddress(libusb_dll, "usb_get_busses"); + _usb_install_service_np = (usb_install_service_np_t) + GetProcAddress(libusb_dll, "usb_install_service_np"); + _usb_uninstall_service_np = (usb_uninstall_service_np_t) + GetProcAddress(libusb_dll, "usb_uninstall_service_np"); + _usb_install_driver_np = (usb_install_driver_np_t) + GetProcAddress(libusb_dll, "usb_install_driver_np"); + _usb_get_version = (usb_get_version_t) + GetProcAddress(libusb_dll, "usb_get_version"); + _usb_isochronous_setup_async = (usb_isochronous_setup_async_t) + GetProcAddress(libusb_dll, "usb_isochronous_setup_async"); + _usb_bulk_setup_async = (usb_bulk_setup_async_t) + GetProcAddress(libusb_dll, "usb_bulk_setup_async"); + _usb_interrupt_setup_async = (usb_interrupt_setup_async_t) + GetProcAddress(libusb_dll, "usb_interrupt_setup_async"); + _usb_submit_async = (usb_submit_async_t) + GetProcAddress(libusb_dll, "usb_submit_async"); + _usb_reap_async = (usb_reap_async_t) + GetProcAddress(libusb_dll, "usb_reap_async"); + _usb_free_async = (usb_free_async_t) + GetProcAddress(libusb_dll, "usb_free_async"); + + if(_usb_init) + _usb_init(); +} + +usb_dev_handle *usb_open(struct usb_device *dev) +{ + if(_usb_open) + return _usb_open(dev); + else + return NULL; +} + +int usb_close(usb_dev_handle *dev) +{ + if(_usb_close) + return _usb_close(dev); + else + return -ENOFILE; +} + +int usb_get_string(usb_dev_handle *dev, int index, int langid, char *buf, + size_t buflen) +{ + if(_usb_get_string) + return _usb_get_string(dev, index, langid, buf, buflen); + else + return -ENOFILE; +} + +int usb_get_string_simple(usb_dev_handle *dev, int index, char *buf, + size_t buflen) +{ + if(_usb_get_string_simple) + return _usb_get_string_simple(dev, index, buf, buflen); + else + return -ENOFILE; +} + +int usb_get_descriptor_by_endpoint(usb_dev_handle *udev, int ep, + unsigned char type, unsigned char index, + void *buf, int size) +{ + if(_usb_get_descriptor_by_endpoint) + return _usb_get_descriptor_by_endpoint(udev, ep, type, index, buf, size); + else + return -ENOFILE; +} + +int usb_get_descriptor(usb_dev_handle *udev, unsigned char type, + unsigned char index, void *buf, int size) +{ + if(_usb_get_descriptor) + return _usb_get_descriptor(udev, type, index, buf, size); + else + return -ENOFILE; +} + +int usb_bulk_write(usb_dev_handle *dev, int ep, char *bytes, int size, + int timeout) +{ + if(_usb_bulk_write) + return _usb_bulk_write(dev, ep, bytes, size, timeout); + else + return -ENOFILE; +} + +int usb_bulk_read(usb_dev_handle *dev, int ep, char *bytes, int size, + int timeout) +{ + if(_usb_bulk_read) + return _usb_bulk_read(dev, ep, bytes, size, timeout); + else + return -ENOFILE; +} + +int usb_interrupt_write(usb_dev_handle *dev, int ep, char *bytes, int size, + int timeout) +{ + if(_usb_interrupt_write) + return _usb_interrupt_write(dev, ep, bytes, size, timeout); + else + return -ENOFILE; +} + +int usb_interrupt_read(usb_dev_handle *dev, int ep, char *bytes, int size, + int timeout) +{ + if(_usb_interrupt_read) + return _usb_interrupt_read(dev, ep, bytes, size, timeout); + else + return -ENOFILE; +} + +int usb_control_msg(usb_dev_handle *dev, int requesttype, int request, + int value, int index, char *bytes, int size, + int timeout) +{ + if(_usb_control_msg) + return _usb_control_msg(dev, requesttype, request, value, index, bytes, + size, timeout); + else + return -ENOFILE; +} + +int usb_set_configuration(usb_dev_handle *dev, int configuration) +{ + if(_usb_set_configuration) + return _usb_set_configuration(dev, configuration); + else + return -ENOFILE; +} + +int usb_claim_interface(usb_dev_handle *dev, int interface) +{ + if(_usb_claim_interface) + return _usb_claim_interface(dev, interface); + else + return -ENOFILE; +} + +int usb_release_interface(usb_dev_handle *dev, int interface) +{ + if(_usb_release_interface) + return _usb_release_interface(dev, interface); + else + return -ENOFILE; +} + +int usb_set_altinterface(usb_dev_handle *dev, int alternate) +{ + if(_usb_set_altinterface) + return _usb_set_altinterface(dev, alternate); + else + return -ENOFILE; +} + +int usb_resetep(usb_dev_handle *dev, unsigned int ep) +{ + if(_usb_resetep) + return _usb_resetep(dev, ep); + else + return -ENOFILE; +} + +int usb_clear_halt(usb_dev_handle *dev, unsigned int ep) +{ + if(_usb_clear_halt) + return _usb_clear_halt(dev, ep); + else + return -ENOFILE; +} + +int usb_reset(usb_dev_handle *dev) +{ + if(_usb_reset) + return _usb_reset(dev); + else + return -ENOFILE; +} + +char *usb_strerror(void) +{ + if(_usb_strerror) + return _usb_strerror(); + else + return NULL; +} + +void usb_set_debug(int level) +{ + if(_usb_set_debug) + return _usb_set_debug(level); +} + +int usb_find_busses(void) +{ + if(_usb_find_busses) + return _usb_find_busses(); + else + return -ENOFILE; +} + +int usb_find_devices(void) +{ + if(_usb_find_devices) + return _usb_find_devices(); + else + return -ENOFILE; +} + +struct usb_device *usb_device(usb_dev_handle *dev) +{ + if(_usb_device) + return _usb_device(dev); + else + return NULL; +} + +struct usb_bus *usb_get_busses(void) +{ + if(_usb_get_busses) + return _usb_get_busses(); + else + return NULL; +} + +int usb_install_service_np(void) +{ + if(_usb_install_service_np) + return _usb_install_service_np(); + else + return -ENOFILE; +} + +int usb_uninstall_service_np(void) +{ + if(_usb_uninstall_service_np) + return _usb_uninstall_service_np(); + else + return -ENOFILE; +} + +int usb_install_driver_np(const char *inf_file) +{ + if(_usb_install_driver_np) + return _usb_install_driver_np(inf_file); + else + return -ENOFILE; +} + +const struct usb_version *usb_get_version(void) +{ + if(_usb_get_version) + return _usb_get_version(); + else + return NULL; +} + +int usb_isochronous_setup_async(usb_dev_handle *dev, void **context, + unsigned char ep, int pktsize) +{ + if(_usb_isochronous_setup_async) + return _usb_isochronous_setup_async(dev, context, ep, pktsize); + else + return -ENOFILE; +} + +int usb_bulk_setup_async(usb_dev_handle *dev, void **context, + unsigned char ep) +{ + if(_usb_bulk_setup_async) + return _usb_bulk_setup_async(dev, context, ep); + else + return -ENOFILE; +} + +int usb_interrupt_setup_async(usb_dev_handle *dev, void **context, + unsigned char ep) +{ + if(_usb_interrupt_setup_async) + return _usb_interrupt_setup_async(dev, context, ep); + else + return -ENOFILE; +} + +int usb_submit_async(void *context, char *bytes, int size) +{ + if(_usb_submit_async) + return _usb_submit_async(context, bytes, size); + else + return -ENOFILE; +} + +int usb_reap_async(void *context, int timeout) +{ + if(_usb_reap_async) + return _usb_reap_async(context, timeout); + else + return -ENOFILE; +} + +int usb_free_async(void **context) +{ + if(_usb_free_async) + return _usb_free_async(context); + else + return -ENOFILE; +} diff --git a/src/libusb_dyn.h b/src/libusb_dyn.h new file mode 100644 index 0000000..9fc43d4 --- /dev/null +++ b/src/libusb_dyn.h @@ -0,0 +1,394 @@ +#ifndef __USB_H__ +#define __USB_H__ + +#include +#include + +/* + * 'interface' is defined somewhere in the Windows header files. This macro + * is deleted here to avoid conflicts and compile errors. + */ + +#ifdef interface +#undef interface +#endif + +/* + * PATH_MAX from limits.h can't be used on Windows if the dll and + * import libraries are build/used by different compilers + */ + +#define LIBUSB_PATH_MAX 512 + + +/* + * USB spec information + * + * This is all stuff grabbed from various USB specs and is pretty much + * not subject to change + */ + +/* + * Device and/or Interface Class codes + */ +#define USB_CLASS_PER_INTERFACE 0 /* for DeviceClass */ +#define USB_CLASS_AUDIO 1 +#define USB_CLASS_COMM 2 +#define USB_CLASS_HID 3 +#define USB_CLASS_PRINTER 7 +#define USB_CLASS_MASS_STORAGE 8 +#define USB_CLASS_HUB 9 +#define USB_CLASS_DATA 10 +#define USB_CLASS_VENDOR_SPEC 0xff + +/* + * Descriptor types + */ +#define USB_DT_DEVICE 0x01 +#define USB_DT_CONFIG 0x02 +#define USB_DT_STRING 0x03 +#define USB_DT_INTERFACE 0x04 +#define USB_DT_ENDPOINT 0x05 + +#define USB_DT_HID 0x21 +#define USB_DT_REPORT 0x22 +#define USB_DT_PHYSICAL 0x23 +#define USB_DT_HUB 0x29 + +/* + * Descriptor sizes per descriptor type + */ +#define USB_DT_DEVICE_SIZE 18 +#define USB_DT_CONFIG_SIZE 9 +#define USB_DT_INTERFACE_SIZE 9 +#define USB_DT_ENDPOINT_SIZE 7 +#define USB_DT_ENDPOINT_AUDIO_SIZE 9 /* Audio extension */ +#define USB_DT_HUB_NONVAR_SIZE 7 + + +/* ensure byte-packed structures */ +#include + + +/* All standard descriptors have these 2 fields in common */ +struct usb_descriptor_header { + unsigned char bLength; + unsigned char bDescriptorType; +}; + +/* String descriptor */ +struct usb_string_descriptor { + unsigned char bLength; + unsigned char bDescriptorType; + unsigned short wData[1]; +}; + +/* HID descriptor */ +struct usb_hid_descriptor { + unsigned char bLength; + unsigned char bDescriptorType; + unsigned short bcdHID; + unsigned char bCountryCode; + unsigned char bNumDescriptors; +}; + +/* Endpoint descriptor */ +#define USB_MAXENDPOINTS 32 +struct usb_endpoint_descriptor { + unsigned char bLength; + unsigned char bDescriptorType; + unsigned char bEndpointAddress; + unsigned char bmAttributes; + unsigned short wMaxPacketSize; + unsigned char bInterval; + unsigned char bRefresh; + unsigned char bSynchAddress; + + unsigned char *extra; /* Extra descriptors */ + int extralen; +}; + +#define USB_ENDPOINT_ADDRESS_MASK 0x0f /* in bEndpointAddress */ +#define USB_ENDPOINT_DIR_MASK 0x80 + +#define USB_ENDPOINT_TYPE_MASK 0x03 /* in bmAttributes */ +#define USB_ENDPOINT_TYPE_CONTROL 0 +#define USB_ENDPOINT_TYPE_ISOCHRONOUS 1 +#define USB_ENDPOINT_TYPE_BULK 2 +#define USB_ENDPOINT_TYPE_INTERRUPT 3 + +/* Interface descriptor */ +#define USB_MAXINTERFACES 32 +struct usb_interface_descriptor { + unsigned char bLength; + unsigned char bDescriptorType; + unsigned char bInterfaceNumber; + unsigned char bAlternateSetting; + unsigned char bNumEndpoints; + unsigned char bInterfaceClass; + unsigned char bInterfaceSubClass; + unsigned char bInterfaceProtocol; + unsigned char iInterface; + + struct usb_endpoint_descriptor *endpoint; + + unsigned char *extra; /* Extra descriptors */ + int extralen; +}; + +#define USB_MAXALTSETTING 128 /* Hard limit */ + +struct usb_interface { + struct usb_interface_descriptor *altsetting; + + int num_altsetting; +}; + +/* Configuration descriptor information.. */ +#define USB_MAXCONFIG 8 +struct usb_config_descriptor { + unsigned char bLength; + unsigned char bDescriptorType; + unsigned short wTotalLength; + unsigned char bNumInterfaces; + unsigned char bConfigurationValue; + unsigned char iConfiguration; + unsigned char bmAttributes; + unsigned char MaxPower; + + struct usb_interface *interface; + + unsigned char *extra; /* Extra descriptors */ + int extralen; +}; + +/* Device descriptor */ +struct usb_device_descriptor { + unsigned char bLength; + unsigned char bDescriptorType; + unsigned short bcdUSB; + unsigned char bDeviceClass; + unsigned char bDeviceSubClass; + unsigned char bDeviceProtocol; + unsigned char bMaxPacketSize0; + unsigned short idVendor; + unsigned short idProduct; + unsigned short bcdDevice; + unsigned char iManufacturer; + unsigned char iProduct; + unsigned char iSerialNumber; + unsigned char bNumConfigurations; +}; + +struct usb_ctrl_setup { + unsigned char bRequestType; + unsigned char bRequest; + unsigned short wValue; + unsigned short wIndex; + unsigned short wLength; +}; + +/* + * Standard requests + */ +#define USB_REQ_GET_STATUS 0x00 +#define USB_REQ_CLEAR_FEATURE 0x01 +/* 0x02 is reserved */ +#define USB_REQ_SET_FEATURE 0x03 +/* 0x04 is reserved */ +#define USB_REQ_SET_ADDRESS 0x05 +#define USB_REQ_GET_DESCRIPTOR 0x06 +#define USB_REQ_SET_DESCRIPTOR 0x07 +#define USB_REQ_GET_CONFIGURATION 0x08 +#define USB_REQ_SET_CONFIGURATION 0x09 +#define USB_REQ_GET_INTERFACE 0x0A +#define USB_REQ_SET_INTERFACE 0x0B +#define USB_REQ_SYNCH_FRAME 0x0C + +#define USB_TYPE_STANDARD (0x00 << 5) +#define USB_TYPE_CLASS (0x01 << 5) +#define USB_TYPE_VENDOR (0x02 << 5) +#define USB_TYPE_RESERVED (0x03 << 5) + +#define USB_RECIP_DEVICE 0x00 +#define USB_RECIP_INTERFACE 0x01 +#define USB_RECIP_ENDPOINT 0x02 +#define USB_RECIP_OTHER 0x03 + +/* + * Various libusb API related stuff + */ + +#define USB_ENDPOINT_IN 0x80 +#define USB_ENDPOINT_OUT 0x00 + +/* Error codes */ +#define USB_ERROR_BEGIN 500000 + +/* + * This is supposed to look weird. This file is generated from autoconf + * and I didn't want to make this too complicated. + */ +#define USB_LE16_TO_CPU(x) + +/* Data types */ +/* struct usb_device; */ +/* struct usb_bus; */ + +struct usb_device { + struct usb_device *next, *prev; + + char filename[LIBUSB_PATH_MAX]; + + struct usb_bus *bus; + + struct usb_device_descriptor descriptor; + struct usb_config_descriptor *config; + + void *dev; /* Darwin support */ + + unsigned char devnum; + + unsigned char num_children; + struct usb_device **children; +}; + +struct usb_bus { + struct usb_bus *next, *prev; + + char dirname[LIBUSB_PATH_MAX]; + + struct usb_device *devices; + unsigned long location; + + struct usb_device *root_dev; +}; + +/* Version information, Windows specific */ +struct usb_version { + struct { + int major; + int minor; + int micro; + int nano; + } dll; + struct { + int major; + int minor; + int micro; + int nano; + } driver; +}; + + +struct usb_dev_handle; +typedef struct usb_dev_handle usb_dev_handle; + +/* Variables */ +#ifndef __USB_C__ +#define usb_busses usb_get_busses() +#endif + + + +#include + + +#ifdef __cplusplus +extern "C" { +#endif + + /* Function prototypes */ + + /* usb.c */ + usb_dev_handle *usb_open(struct usb_device *dev); + int usb_close(usb_dev_handle *dev); + int usb_get_string(usb_dev_handle *dev, int index, int langid, char *buf, + size_t buflen); + int usb_get_string_simple(usb_dev_handle *dev, int index, char *buf, + size_t buflen); + + /* descriptors.c */ + int usb_get_descriptor_by_endpoint(usb_dev_handle *udev, int ep, + unsigned char type, unsigned char index, + void *buf, int size); + int usb_get_descriptor(usb_dev_handle *udev, unsigned char type, + unsigned char index, void *buf, int size); + + /* .c */ + int usb_bulk_write(usb_dev_handle *dev, int ep, char *bytes, int size, + int timeout); + int usb_bulk_read(usb_dev_handle *dev, int ep, char *bytes, int size, + int timeout); + int usb_interrupt_write(usb_dev_handle *dev, int ep, char *bytes, int size, + int timeout); + int usb_interrupt_read(usb_dev_handle *dev, int ep, char *bytes, int size, + int timeout); + int usb_control_msg(usb_dev_handle *dev, int requesttype, int request, + int value, int index, char *bytes, int size, + int timeout); + int usb_set_configuration(usb_dev_handle *dev, int configuration); + int usb_claim_interface(usb_dev_handle *dev, int interface); + int usb_release_interface(usb_dev_handle *dev, int interface); + int usb_set_altinterface(usb_dev_handle *dev, int alternate); + int usb_resetep(usb_dev_handle *dev, unsigned int ep); + int usb_clear_halt(usb_dev_handle *dev, unsigned int ep); + int usb_reset(usb_dev_handle *dev); + + char *usb_strerror(void); + + void usb_init(void); + void usb_set_debug(int level); + int usb_find_busses(void); + int usb_find_devices(void); + struct usb_device *usb_device(usb_dev_handle *dev); + struct usb_bus *usb_get_busses(void); + + + /* Windows specific functions */ + + #define LIBUSB_HAS_INSTALL_SERVICE_NP 1 + int usb_install_service_np(void); + void CALLBACK usb_install_service_np_rundll(HWND wnd, HINSTANCE instance, + LPSTR cmd_line, int cmd_show); + + #define LIBUSB_HAS_UNINSTALL_SERVICE_NP 1 + int usb_uninstall_service_np(void); + void CALLBACK usb_uninstall_service_np_rundll(HWND wnd, HINSTANCE instance, + LPSTR cmd_line, int cmd_show); + + #define LIBUSB_HAS_INSTALL_DRIVER_NP 1 + int usb_install_driver_np(const char *inf_file); + void CALLBACK usb_install_driver_np_rundll(HWND wnd, HINSTANCE instance, + LPSTR cmd_line, int cmd_show); + + #define LIBUSB_HAS_TOUCH_INF_FILE_NP 1 + int usb_touch_inf_file_np(const char *inf_file); + void CALLBACK usb_touch_inf_file_np_rundll(HWND wnd, HINSTANCE instance, + LPSTR cmd_line, int cmd_show); + + #define LIBUSB_HAS_INSTALL_NEEDS_RESTART_NP 1 + int usb_install_needs_restart_np(void); + + const struct usb_version *usb_get_version(void); + + int usb_isochronous_setup_async(usb_dev_handle *dev, void **context, + unsigned char ep, int pktsize); + int usb_bulk_setup_async(usb_dev_handle *dev, void **context, + unsigned char ep); + int usb_interrupt_setup_async(usb_dev_handle *dev, void **context, + unsigned char ep); + + int usb_submit_async(void *context, char *bytes, int size); + int usb_reap_async(void *context, int timeout); + int usb_reap_async_nocancel(void *context, int timeout); + int usb_cancel_async(void *context); + int usb_free_async(void **context); + + +#ifdef __cplusplus +} +#endif + +#endif /* __USB_H__ */ + diff --git a/src/rfid.c b/src/rfid.c index fa98220..9df85a0 100644 --- a/src/rfid.c +++ b/src/rfid.c @@ -17,6 +17,7 @@ #include #include +#include #include #include #include @@ -32,6 +33,7 @@ struct rfid_reader_handle rfid_rh; #endif #ifndef LIBRFID_FIRMWARE +#ifdef LIBRFID_DEBUG const char * rfid_hexdump(const void *data, unsigned int len) { @@ -48,6 +50,7 @@ rfid_hexdump(const void *data, unsigned int len) } return string; } +#endif/*LIBRFID_DEBUG*/ #else #define rfid_hexdump(x, y) hexdump(x, y) #endif diff --git a/src/rfid_access_mifare_classic.c b/src/rfid_access_mifare_classic.c index bd362e1..03cb1e5 100644 --- a/src/rfid_access_mifare_classic.c +++ b/src/rfid_access_mifare_classic.c @@ -1,7 +1,6 @@ #include #include #include -#include #include #include @@ -229,4 +228,3 @@ char *mfcl_access_exp_acc_stringify(const struct mfcl_access_exp_acc *acc) mfcl_access_str[acc->key_b_wr]); return buf; } - diff --git a/src/rfid_asic_rc632.c b/src/rfid_asic_rc632.c index 0560d09..6fa4ee3 100644 --- a/src/rfid_asic_rc632.c +++ b/src/rfid_asic_rc632.c @@ -35,8 +35,10 @@ #include "rfid_iso14443_common.h" #include "rc632.h" -//#include "rc632_14443a.h" +#ifdef __MINGW32__ +#include "usleep.h" +#endif/*__MINGW32__*/ #define RC632_TMO_AUTH1 140 @@ -608,7 +610,7 @@ rc632_open(struct rfid_asic_transport_handle *th) return NULL; memset(h, 0, sizeof(*h)); - h->asic = &rc632; + h->asic = (void*)&rc632; h->rath = th; h->fc = h->asic->fc; /* FIXME: this is only cm5121 specific, since the latency diff --git a/src/rfid_reader_openpcd.c b/src/rfid_reader_openpcd.c index f439c04..866bef4 100644 --- a/src/rfid_reader_openpcd.c +++ b/src/rfid_reader_openpcd.c @@ -56,7 +56,12 @@ static struct openpcd_hdr *rcv_hdr; #ifndef LIBRFID_FIRMWARE +#ifdef __MINGW32__ +#include "libusb_dyn.h" +#else /*__MINGW32__*/ #include +#endif/*__MINGW32__*/ + static struct usb_device *dev; static struct usb_dev_handle *hdl; diff --git a/src/usleep.c b/src/usleep.c new file mode 100644 index 0000000..9f76bcb --- /dev/null +++ b/src/usleep.c @@ -0,0 +1,30 @@ +#include +#include + +void usleep(unsigned long usec) +{ + int msec; + + msec=usec/1000; + usec=usec%1000; + + if(msec) + { + if(usec) + msec++; + } + else + { + LARGE_INTEGER current,freq,end; + + QueryPerformanceFrequency(&freq); + QueryPerformanceCounter(&end); + + end.QuadPart+=(freq.QuadPart*usec)/1000000; + while(QueryPerformanceCounter(¤t) && (current.QuadPart<=end.QuadPart)) + { + } + } + + Sleep(msec); +} diff --git a/src/usleep.h b/src/usleep.h new file mode 100644 index 0000000..c23bae0 --- /dev/null +++ b/src/usleep.h @@ -0,0 +1,6 @@ +#ifndef __USLEEP_H__ +#define __USLEEP_H__ + +void usleep(unsigned long usec); + +#endif/*__USLEEP_H__*/ diff --git a/utils/Makefile.am b/utils/Makefile.am index abae91c..598a6ea 100644 --- a/utils/Makefile.am +++ b/utils/Makefile.am @@ -8,13 +8,18 @@ noinst_HEADERS = librfid-tool.h librfid_tool_SOURCES = librfid-tool.c common.c librfid_tool_LDADD = ../src/librfid.la -librfid_tool_LDFLAGS = -dynamic librfid_send_script_SOURCES= send_script.c librfid_send_script_LDADD = ../src/librfid.la -librfid_send_script_LDFLAGS = -dynamic mifare_tool_SOURCES = mifare-tool.c common.c mifare_tool_LDADD = ../src/librfid.la -mifare_tool_LDFLAGS = -dynamic + +if ENABLE_WIN32 +LINKOPTS = -dynamic -mno-cygwin +librfid_send_script_LDFLAGS = $(LINKOPTS) +librfid_tool_LDFLAGS = $(LINKOPTS) +mifare_tool_LDFLAGS = $(LINKOPTS) +endif + endif diff --git a/utils/common.c b/utils/common.c index 2966ab4..53acbdd 100644 --- a/utils/common.c +++ b/utils/common.c @@ -3,7 +3,7 @@ #include #include #include -#include +//#include #include #include diff --git a/utils/librfid-tool.c b/utils/librfid-tool.c index be6e843..020b837 100644 --- a/utils/librfid-tool.c +++ b/utils/librfid-tool.c @@ -21,7 +21,7 @@ #include #include #include -#include +/*#include */ #define _GNU_SOURCE #include @@ -352,7 +352,7 @@ void register_module(struct rfidtool_module *me) old = find_module(me->name); if (old) { - fprintf(stderr, "%s: target `%s' already registere.\n", + fprintf(stderr, "%s: target `%s' already registered.\n", program_name, me->name); exit(1); } @@ -370,10 +370,14 @@ static void help(void) int main(int argc, char **argv) { int rc; - char buf[0x40]; - int i, protocol = -1, layer2 = -1; + char buf[0x100]; + int i, len, protocol = -1, layer2 = -1; +#ifdef __MINGW32__ + program_name = argv[0]; +#else /*__MINGW32__*/ program_name = basename(argv[0]); +#endif/*__MINGW32__*/ printf("%s - (C) 2006 by Harald Welte\n" "This program is Free Software and has " @@ -450,8 +454,6 @@ int main(int argc, char **argv) exit(1); switch (protocol) { - char buf[32000]; - int len = 200; case RFID_PROTOCOL_TCL: printf("Protocol T=CL\n"); @@ -493,7 +495,7 @@ int main(int argc, char **argv) while (1) { printf("reading EF1\n"); - len = 200; + len = sizeof(buf); printf("reading ef\n"); rc = iso7816_read_binary(buf, &len); if (rc < 0) { diff --git a/utils/mifare-tool.c b/utils/mifare-tool.c index 4062eaa..aebd0d0 100644 --- a/utils/mifare-tool.c +++ b/utils/mifare-tool.c @@ -21,7 +21,7 @@ #include #include #include -#include +//#include #define _GNU_SOURCE #include @@ -95,7 +95,12 @@ int main(int argc, char **argv) unsigned int page; char key[MIFARE_CL_KEY_LEN]; char buf[MIFARE_CL_PAGE_SIZE]; + +#ifdef __MINGW32__ + program_name = argv[0]; +#else program_name = basename(argv[0]); +#endif/*__MINGW32__*/ memcpy(key, MIFARE_CL_KEYA_DEFAULT_INFINEON, sizeof(MIFARE_CL_KEYA_DEFAULT_INFINEON));